I don't know "exactly" how it changes the calculus, in the sense that I don't have a formal statement measuring the difference (and I am not aware that there exists one), but allowing reduction under prefixes does change the semantics of the calculus "non-trivially", as the following example shows.
Let
$\qquad P\ :=\ \nu(x,y,z)(x(w).(w \mathrel| \overline w.a \mathrel| \overline{y}.b) \mathrel| \overline{x}y \mathrel| \overline xz.c)$
$\qquad S\ :=\ \tau.(\tau.a+\tau.b)+\tau.(\tau.a\mathrel|c)$
$\qquad S'\ :=\ \tau.(\tau.a+\tau.(a\mathrel|c))+S$
Whatever definition of reduction you choose, $S$ and $S'$ are not bisimilar. Now, in Milner's calculus, $P$ is bisimilar to $S$. If you allow reduction under prefix, $P$ becomes bisimilar to $S'$.
(Intuitively, the difference between $S$ and $S'$ is that $S'$ may "lose" the barb on $b$ without necessarily exposing a barb on $c$, which is what $S$ must do instead.
Technically, $S$ and $S'$ are not weakly barbed bisimilar, which implies that they are not weakly barbed congruent, which implies that they are not weakly bisimilar, or anything stroger. Indeed, opponent can always win the barbed bisimilarity game against me (player) by starting with the reduction
$$S'\to \tau.a+\tau.(a\mathrel|c)\ =:\ S_1'.$$
To respond, I need to reduce $S$ (arbitrarily many times, including none) ending up on a term having the same weak barbs as $S_1'$, which are $a$ and $c$. Now, the reducts of $S$ having exactly $a$ and $c$ as weak barbs are $\tau.a\mathrel|c$ and its immediate reduct $a\mathrel| c$. Whichever I choose, opponent's next move is going to select the reduction $S_1'\to a$, ending on a process whose only barb is $a$. There is no way for me to match this reduction, because any process I may reduce to will have barbs on both $a$ and $c$, and so I'm toast).
Forbidding reduction under input prefixes corresponds to the fact that read/receive operations are blocking, which is quite natural in programming languages. When we are waiting for some information to be received and we decide to proceed without, we might make "bad" choices. In the example, we proceed as if $w$ could not become equal to $y$. If you think about passing values other than names (for example, integers), the phenomenon should become even more apparent intuitively.
In a deterministic context (like the $\lambda$-calculus), proceeding without knowing the value of an input parameter (like reducing $M$ in $\lambda x.\!M$) is fine, but in a concurrent context it is not a good idea.
The story is different for output prefixes and, in fact, many do consider them to be non-blocking, to the point that they force $\mathbf 0$ (the inactive process) to be the only process allowed under an output prefix. This is known as the asynchronous $\pi$-calculus and its expressiveness with respect to the synchronous version is well understood, in the sense that there are synchronous processes which may be simulated asynchronously only introducing divergence (see especially the work by Catuscia Palamidessi about this).
