Why do these two methods of sampling primes run equally long?

So I've implemented my own little RSA algorithm and in the course of that I wrote a function to find large prime numbers.
First I wrote a function prime? that tests for primality and then I wrote two versions of a prime searching function. In the first version I just test random BigIntegers until I hit a prime. In the second version I sample a random BigInteger and then incremented it until I find a prime.

(defn resampling []
  (let [rnd (Random.)]
    (->> (repeatedly #(BigInteger. 512 rnd))
         (take-while (comp not prime?))
         (count))))

(defn incrementing []
  (->> (BigInteger. 512 (Random.))
       (iterate inc)
       (take-while (comp not prime?))
       (count)))

(let [n 100]
  {:resampling   (/ (reduce + (repeatedly n resampling)) n)
   :incrementing (/ (reduce + (repeatedly n incrementing)) n)})

Running this code yielded the two averages of 332.41 for the resampling function and 310.74 for the incrementing function.
Now the first number makes complete sense to me. The prime number theorem states that the n'th prime is about n*ln(n) in size (where ln is the natural logarithm). So the distance between adjacent primes is approximately n*ln(n) - (n-1)*ln(n-1) ≈ (n - (n - 1))*ln(n) = ln(n) (For large values of n ln(n) ≈ ln(n - 1)). Since I'm sampling 512-bit integers I'd expect the distance between primes to be in the vicinity of ln(2^512) = 354.89. Therefore random sampling should take about 354.89 attempts on average before hitting a prime, which comes out quite nicely.
The puzzle for me is why the incrementing function is taking about just as many steps. If I imagine throwing a dart at a grid where primes are spaced 355 units apart, it should take only about half that many steps on average to walk to the next higher prime, since on average I'd be hitting the center between two primes.

(The code for prime? is a little lengthy. You can take a look at it here.)