Maybe something like this:

img = Import["https://i.sstatic.net/0Jl54.png"]

text = TextRecognize @ img

del = {"the worst", "of times"};

Rasterize[#, RasterSize -> 1000, ImageSize -> ImageDimensions @ img]& @
   Style[#, FontFamily -> "Times"]& @
 StringReplace[
  text, {del[[1]] -> StringPadRight["", StringLength @ del[[1]]], 
   del[[2]] -> StringPadRight["", StringLength @ del[[2]]]}]

PLEASE NOTE

There is a reason why watermarks are there in the first place - to prevent unauthorised reuse of images. For more information on the issues around removing watermarks from images, this Wikimedia article is just one of many useful resources.

The answer below is intended as an exercise in automatically removing text from an image using the inpainting technique. The first part of this answer assumes an unknown text overlay using binarization. The second part of the answer attempts to deal with a known overlay image but unknown position, using image correlation.

Part 1 - Unknown overlay text, unknown position

For scenarios where the text is a given colour that differs a lot from the rest of the image, this is a job for ChanVeseBinarize[]. It even works fairly well with translucent text - here's an example with a bit of translucent white text, using a Mathematica test image:

image = Import["https://i.sstatic.net/LyJTe.png"]

(* This is where parameters become important *)
binimg = ChanVeseBinarize[image, White, {Automatic, 0.12}, MaxIterations -> 1000];

(* Now we can create the mask *)
maskimg = Dilation[DeleteSmallComponents[binimg, 4], 2.5];

And finally the inpainting, making use of the method options to improve the result. It introduces a few artifacts due to an imperfect mask (for example, look at the red edge of the nose), but it's not bad given the text was translucent to start off with. With fully-white text, it's much better.

Inpaint[image, maskimg, Method -> {"TextureSynthesis", "MaxSamples" -> 1200}, MaxIterations -> 500]

Part 2 - Known overlay text, unknown position

This deals with a known piece of overlay text, and makes use of ImageCorrelate[]. Here I make no change to the size or orientation of the overlay, but if you look in the documentation of ImageCorrelate[] under "Generalizations and Extensions" you'll see an example of finding rotated occurrences of a template.

(* The test image is ExampleData[{"TestImage", "Mandrill"}] *)

overlay = Graphics@Text[Style["I love stackexchange", FontFamily -> "Arial", 
    FontSize -> 32, Bold, White, Opacity[0.8]]];

(* Or you can just import an image I've already prepared *)
compositeimage = Import["https://i.sstatic.net/DJEWm.png"]

Then we use ImageCorrelate[] to find the most likely position for the text in the image, and MaxDetect to extract its position (the white dot).

corrimage = ImageAdjust@ImageCorrelate[compositeimage, Binarize@overlay];
maxdetect = MaxDetect[ImageAdjust@DistanceTransform@Binarize[corrimage, 0.9]];
maxpos = Flatten@PixelValuePositions[maxdetect, 1];

(* This combines the overlay into a mask at the correct position *)
blankimage = Image@ConstantArray[0, ImageDimensions@compositeimage];
maskimage = ImageCompose[blankimage, Binarize@overlay, maxpos];
(* Dilation important to ensure full coverage of the mask *)
maskimage = Dilation[maskimage, 2];

Finally we can construct a mask from this information and inpaint. Here the performance is much better than above, because the mask is better.

Inpaint[compositeimage, maskimage, 
 Method -> {"TextureSynthesis", "MaxSamples" -> 1200}, 
 MaxIterations -> 500]

MorphologicalBinarize and ColorNegate it. We use Manipulate to choose the finest parameter.

img = Image[
    Import["https://maps.googleapis.com/maps/api/staticmap?center=+51.\
    5+-0.116667&zoom=10&size=600x600&scale=2&style=feature:road.highway%\
    7Ccolor:0x000000%7Cweight:1%7Cvisibility:on"], ImageSize -> Medium];

Manipulate[
  img2 = DeleteSmallComponents@
   ColorNegate[MorphologicalBinarize[img, {x, y}]], {x, 0, 1}, {y, 0, 
1}]

Then we dilate img2 and find the largest connected component. Manipulate is used here again for parameter issues. To better show the result, we combine the detected roads with the original map.

Manipulate[
 r = Dilation[img2, x] // 
   MorphologicalComponents[#, CornerNeighbors -> False] &; 
    road = Commonest[Flatten[r], 2][[2]]; 
 ImageAdd[img, 
  ColorReplace[
   Dilation[
    img3 = Pruning[
  Thinning@Image[r /. {road -> 1, x_ /; x != road :> 0}], 10], 1],
    White -> Red]], {x, 0, 3}]

The final result.

This is a fast and quite good way to create the mask of the spider:

i = Import["http://i.stack.imgur.com/2Lz0A.jpg"];
mask = Dilation[
  DeleteSmallComponents@ ColorNegate@ DeleteSmallComponents@
    MorphologicalBinarize[i, .25], 
  DiskMatrix[2]]

Then, you can use Inpaint with the generated mask:

Inpaint[i, mask]

You will have to adjust the MorphologicalBinarize threshold value to achieve good results for other images.

Almost!

Convert your image to binary image

img = Import["https://i.sstatic.net/uRUEw.jpg"];
binimg = ColorNegate@Binarize[img, .75]

Get tha mask used in Inpaint

mask = SelectComponents[binimg, {"PerimeterLength", "Elongation"}, 
  60 < # < 160 || #2 > 0.8 &]

Contrasting your image with after.

Grid[{{"Before", Magnify[img, 5]}, {"After",Magnify[Inpaint[img, Dilation[mask, 1], 
     Method -> "TextureSynthesis"], 5]}}]

For this one example, a start might be to extract the different colour layers.

masks = (ColorReplace[#, {Red -> Black, _ -> White}, .2] &) /@ (ImageRecolor[
     i, {# -> Red}] & /@ Rest[DominantColors[i]])

This gives us back two images:

and then we can use these as masks on the original image:

ImageAdd[#, i] & /@ masks

It may be possible to use ImageBoundingBoxes or (more likely) another neural network based approach to separate the text and the boat - ImageBoundingBoxes is apparently not trained on pictures of text.

^{(The "test text" example makes me think this is one of hundreds of images, and it seems unlikely that you will find a blanket solution for this class of problem that doesn't require a fair bit of hand-tweaking per image.)}

I worked with some contrived data and came up with this. I believe the general approach will work with your actual data even some of details need to changed.

Contrived data

data1 = Table[x^1.35 + 50, {x, 0, 33}];
data2 = Table[x^1.35, {x, 0, 33}]; 
places1 =
  Placed[
   {"1", "2", "4", "8", "16", "32"}, 
   Table[{x, Log[x^1.35 + 50]} // N, {x, Subdivide[2, 28, 5]}]];
places2 =
  Placed[
    {"1\!\(\*SubscriptBox[\(T\), \(2\)]\)", 
     Style["2\!\(\*SubscriptBox[\(T\), \(2\)]\)", Background -> Lighter[Gray, .6]], 
     "3\!\(\*SubscriptBox[\(T\), \(2\)]\)", 
     "4\!\(\*SubscriptBox[\(T\), \(2\)]\)", 
     "1\!\(\*SubscriptBox[\(T\), \(1\)]\)", 
     "5\!\(\*SubscriptBox[\(T\), \(2\)]\)", 
     "6\!\(\*SubscriptBox[\(T\), \(2\)]\)", 
     "7\!\(\*SubscriptBox[\(T\), \(2\)]\)", 
     "8\!\(\*SubscriptBox[\(T\), \(2\)]\)", 
     "9\!\(\*SubscriptBox[\(T\), \(2\)]\)"}, 
    N[{#[[1]], Log @ #[[2]]}] & /@ 
     {{3, 1.5}, {5.8, 5}, {9, 12}, {12, 20}, {14, 25}, {16, 32}, 
      {19, 45}, {22, 60}, {25, 90}, {28, 100}}];

The important thing to notice in the above is that because the plot data is going to log scaled, the y-components of label coordinates also have to be log scaled.

Given the properly scaled placements, the plotting can be done with the fairly simple code that follows:

Show[
  ListLinePlot[data1,
    ScalingFunctions -> "Log",
    PlotRange -> {{0, 30}, {0, 200}},
    Frame -> True,
    FrameTicks -> Automatic, 
    FrameLabel -> 
      {Style["T", 14], Style["(E+1/3)\!\(\*SuperscriptBox[\(n\), \(2\)]\)", 14]},
    PlotLabels -> places1],
  ListLinePlot[data2,
    ScalingFunctions -> "Log",
    PlotStyle -> Dashed,
    PlotRange -> {{0, 30}, {0, 200}},
    PlotLabels -> places2],
 ImageSize -> Large]

[

Note that none of labels, except for $2T_2$, has a background

This function implements the reverse blend described by Mark Ransom, for an additional small but visible improvement:

reverseBlend[img_Image, alpha_Image, bgcolor_] :=
 With[
  {c = ImageData[img], 
   a = ImageData[alpha] + 0.0001, (* this is to minimize ComplexInfinitys and considerably improve performance *)
   bc = bgcolor},

  ImageClip@
   Image[Quiet[(c - bc (1 - a))/a, {Power::infy, 
       Infinity::indet}] /. {ComplexInfinity -> 0, Indeterminate -> 0}]
  ]

This is the background removal function. The threshold parameter is used for the initial binarization of the image, the minSizeCorrection is for tweaking the size limit of small junk components to be removed after binarization.

removeWhiteBackground[img_, threshold_: 0.05, minSizeCorrection_: 1] :=
  Module[
  {dim, bigmask, mask, edgemask, alpha},
  dim = ImageDimensions[img];
  bigmask = 
   DeleteSmallComponents[
    ColorNegate@
     MorphologicalBinarize[ColorNegate@ImageResize[img, 4 dim], threshold], 
    Round[minSizeCorrection Times @@ dim/5]];
  mask = ColorNegate@
    ImageResize[ColorConvert[bigmask, "GrayScale"], dim];
  edgemask = 
   ImageResize[
    ImageAdjust@DistanceTransform@Dilation[EdgeDetect[bigmask, 2], 6],
     dim];
  alpha = 
   ImageAdd[
    ImageSubtract[
     ImageMultiply[ColorNegate@ColorConvert[img, "GrayScale"], 
      edgemask], ImageMultiply[mask, edgemask]], mask];
  SetAlphaChannel[reverseBlend[img, alpha, 1], alpha]
  ]

Testing the function:

img = Import["https://i.sstatic.net/k7E1F.png"];

background = 
  ImageCrop[
   Import["http://cdn.zmescience.com/wp-content/uploads/2011/06/\
forest2.jpg"], ImageDimensions[img]];

result = removeWhiteBackground[img]

ImageCompose[background, result]
Rasterize[result, Background -> Red]
Rasterize[result, Background -> Black]

Brief explanation of how it works:

1. Choose your favourite binarization method that produces relatively precise sharp edges

2. Apply it to an up-scaled image, then downscale the obtained mask to the original size. This gives us antialiasing. Most of the work is done.

3. For a small improvement, blend the image onto the background using the brightness of its negative as alpha, then blend the obtained image over the original in a thin region around the edges (edgemask) to reduce the visibility of white pixels on the edges. The alpha channel corresponding to these operations is calculated (the somewhat cryptic ImageMultiply/Add expression).

4. Now we have an estimate of the alpha channel so we can do a reverse blend.

Steps 3 & 4 don't improve that much, but the difference is visible.