How does the bitlength of the divisor affect the running-time complexity of division algorithms?
Let $M(m, n)$ and $D(m, n)$, respectively, be the costs of multiplying and dividing an $m$-digit number by an $n$-digit number (with $m \ge n$). Brent and Zimmermann give the following bounds: 

$$ (1) \qquad M(m,n) \le \left\lceil \frac{m}{n} \right\rceil  M(n) $$
  $$ (2) \qquad M(m,n) \le M \left( \frac{m+n}{2} \right) (1+ o(1)) $$
  $$ (3) \qquad D(m+n,n) \le O(M(m,n)) $$
where $M(n)$ is the complexity of balanced $n$-digit multiplication. 

I am not an expert in this area but I can try to summarize their explanations: 

(1) is based on the idea that if $m = kn$, you can cut the larger operand into $k$ pieces, giving $M(kn, n) = k M(n) + O(kn)$. 

(2) is based on using an evaluation-interpolation scheme and reducing the unbalanced multiplication to a balanced multiplication of two $(m+n)/2$-digit numbers (I realize this is a bit vague, but they don't give much details in this case).

(3) they also don't give a reference in this case; judging from the bound, it may be based on using Newton to compute the reciprocal of the $n$-digit number and then multiplication. One unbalanced division algorithm they do discuss explicitly is based on computing $n$ digits of the quotient at a time, reducing the division to several $2n$ by $n$ divisions, each of which is implemented with the recursive division algorithm. However, the latter does not seem to fit the bound (3). 

For the details, have a look at Sections 1.3.5, 1.4.3, and the table at the end of their monograph.