Okay, I found the mistake... It was a typo (MininmalBy instead of MinimalBy), sorry for bothering. -.-

Realize the software has no "sense", it doesn't look at your problem, perhaps graph it, think a bit and realize it should check all the boundaries, just in case.

Without the Method -> "RandomSearch" it (mostly) looks at some how the values are changing in the immediate neighborhood of some point, calculates in which direction the function is decreasing most rapidly, steps off in that direction by some distance and does this all over again. After repeating this again and again it finds itself in a place where everywhere around it the function is either the same or even increases and it declares that it is done.

With the Method -> "RandomSearch" it (mostly) throws a dart up in the air, goes over and measures the function at that point, if it is smaller than that last best value it keeps this as the new last best value. After a while it doesn't find any better last best values and declares that it is done.

Now imagine in the vast space that your function covers you have one or a few places where the function grows to a very high sharp peak, except at exactly those peaks you have drilled a deep hole of infinitely small diameter.

Without the Method -> "RandomSearch" the software will attempt to run down hills and get far away from peaks. It will not "think" I am going up this peak and making this worse and worse, but I suppose I should keep making it worse, even though you just asked me to minimize this, just in case I find something better up there.

With the Method -> "RandomSearch" there is almost no chance your dart will happen to hit that infinitely small diameter hole in the vast space of your function.

You, on the other hand, can think and realize that your problem includes special cases at the boundaries where your function is not "smooth" and you can check all the special points.

This works without error

In[6]:= NMinimize[{f1[w] + f2[x] + f3[y] + f4[z], {w + x + y + z == 7000,
   0 <= w <= 4000, 0 <= x <= 4000, 0 <= y <= 3000, 0 <= z <= 3000}}, {w, x, y, z}]

Out[6]= {793.412, {w -> 1829.54, x -> 1709.12, y -> 1791.87, z -> 1669.47}}

For this problem this happens to find a smaller minimum

In[7]:= NMinimize[{f1[w] + f2[x] + f3[y] + f4[z], {w + x + y + z == 7000,
   0 <= w <= 4000, 0 <= x <= 4000, 0 <= y <= 3000, 0 <= z <= 3000}}, {w, x, y, z}, 
   Method -> "RandomSearch"]

Out[7]= {583.291, {w -> 2153.49, x -> 0., y -> 2663.08, z -> 2183.44}}

And this finds an even smaller minimum.

In[8]:= NMinimize[{f1[w] + f2[x] + f3[y], {w + x + y == 7000, 
   0 <= w <= 4000, 0 <= x <= 4000, 0 <= y <= 3000}}, {w, x, y}, 
 Method -> "RandomSearch", MaxIterations -> 10^4]

Out[8]= {384.535, {w -> 4000., x -> 0., y -> 3000.}}

I suspect almost any minimization method is going to have problems where some or all your functions have smoothly growing very large values adjacent to isolated points where the functions are much smaller. So if you have functions like that then I suspect that your idea of checking all the isolated points, in addition to using a general minimization method, might be the best approach.