Your point about semantic versus logic errors overlooks the fact that many of the additional semantic errors flagged by a statically typed language may be logic errors in a dynamically typed language.
The real issue here, however, is that despite all the talk over the issue, there is not much hard evidence one way or the other. My theory, which is as soft as any other, is that a programmer needs to know the types in her program (at least in an informal sense) regardless of what the language is doing in support — someone who does can write a well-typed program in a dynamic language, while one who does not will have to resort to extensive trial-and-error to get a program to work, regardless of language.
At first sight, this suggests that static typing would be of considerable help, but type checking as historically implemented is arguably not powerful enough, while being intrusive. More effective approaches, such as the use of category theory, together with more advances in static analysis, such as type deduction, may unleash the promise of static typing, but probably only for programmers who are adept at thinking about their programs in abstract terms.