I;ve done such simulations many times, I really don't follow what results you expect to see. The sample size will determine the estimated effect size if you subset only significant results, but the proportion should be the same if the model is really correct... That said, a short tour through the R source code lead to some interesting findings:

1) The t.test() code utilizes the pt function:

pval <- pt(tstat, df)
[...]
pval <- pt(tstat, df, lower.tail = FALSE)
[...]
pval <- 2 * pt(-abs(tstat), df)

https://svn.r-project.org/R/trunk/src/library/stats/R/t.test.R




2) The algorithm used by the pt() function is determined by the size of the input (cutoff at 400,000). So, at least if you are using R, your example is literally comparing apples to oranges:
  #ifdef R_version_le_260
      if (n > 4e5) { /*-- Fixme(?): test should depend on `n' AND `x' ! */
  	/* Approx. from	 Abramowitz & Stegun 26.7.8 (p.949) */
  	val = 1./(4.*n);
  	return pnorm(x*(1. - val)/sqrt(1. + x*x*2.*val), 0.0, 1.0,
  		     lower_tail, log_p);
      }
  #endif

  nx = 1 + (x/n)*x;
      /* FIXME: This test is probably losing rather than gaining precision,
       * now that pbeta(*, log_p = TRUE) is much better.
       * Note however that a version of this test *is* needed for x*x > D_MAX */
      if(nx > 1e100) { /* <==>  x*x > 1e100 * n  */
  	/* Danger of underflow. So use Abramowitz & Stegun 26.5.4
	   pbeta(z, a, b) ~ z^a(1-z)^b / aB(a,b) ~ z^a / aB(a,b),
  	   with z = 1/nx,  a = n/2,  b= 1/2 :
  	*/
  	double lval;
  	lval = -0.5*n*(2*log(fabs(x)) - log(n))
  		- lbeta(0.5*n, 0.5) - log(0.5*n);
  	val = log_p ? lval : exp(lval);
      } else {
  	val = (n > x * x)
  	    ? pbeta (x * x / (n + x * x), 0.5, n / 2., /*lower_tail*/0, log_p)
  	    : pbeta (1. / nx,             n / 2., 0.5, /*lower_tail*/1, log_p);
      }
https://svn.r-project.org/R/trunk/src/nmath/pt.c




3a) The above pt function utilizes either pnorm() or pbeta() to do the grunt work. The pnorm() funnction includes all sorts of arbitrary constants:

const static double a[5] = {
	2.2352520354606839287,
	161.02823106855587881,
	1067.6894854603709582,
	18154.981253343561249,
	0.065682337918207449113
    };
   [...]
    const static double q[5] = {
	1.28426009614491121,
	0.468238212480865118,
	0.0659881378689285515,
	0.00378239633202758244,
	7.29751555083966205e-5
    };
https://svn.r-project.org/R/trunk/src/nmath/pnorm.c




3b) The pbeta function calls a bratio function, which likewise uses an approximation requires various constants and sqitches between algorithms based on the input arguments, which depend on n (not shown... this is getting too long).

    static double c0 = .0833333333333333;
    static double c1 = -.00277777777760991;
    static double c2 = 7.9365066682539e-4;
    static double c3 = -5.9520293135187e-4;
    static double c4 = 8.37308034031215e-4;
    static double c5 = -.00165322962780713;

https://svn.r-project.org/R/trunk/src/nmath/pbeta.c
https://svn.r-project.org/R/trunk/src/nmath/toms708.c


So, it is possible that whatever you observed is due to numerical error and that software often handles large datasets differently than small datasets.