diff --git a/lib/_stream_readable.js b/lib/_stream_readable.js
index 947a0b9c9a3..ff4bf40214b 100644
--- a/lib/_stream_readable.js
+++ b/lib/_stream_readable.js
@@ -327,19 +327,13 @@ function onread(stream, er, chunk) {
     return;
   }
 
-  // Don't emit readable right away in sync mode, because this can trigger
-  // another read() call => stack overflow.  This way, it might trigger
-  // a nextTick recursion warning, but that's not so bad.
-  if (state.needReadable) {
-    if (!sync)
-      emitReadable(stream);
-    else
-      process.nextTick(function() {
-        emitReadable(stream);
-      });
-  }
+  if (state.needReadable)
+    emitReadable(stream);
 }
 
+// Don't emit readable right away in sync mode, because this can trigger
+// another read() call => stack overflow.  This way, it might trigger
+// a nextTick recursion warning, but that's not so bad.
 function emitReadable(stream) {
   var state = stream._readableState;
   state.needReadable = false;
@@ -347,7 +341,28 @@ function emitReadable(stream) {
     return;
 
   state.emittedReadable = true;
+  if (state.sync)
+    process.nextTick(function() {
+      emitReadable_(stream);
+    });
+  else
+    emitReadable_(stream);
+}
+
+function emitReadable_(stream) {
+  var state = stream._readableState;
   stream.emit('readable');
+
+  // at this point, the user has presumably seen the 'readable' event,
+  // and called read() to consume some data.  that may have triggered
+  // in turn another _read(n,cb) call, in which case reading = true if
+  // it's in progress.
+  // However, if we're not ended, or reading, and the length < hwm,
+  // then go ahead and try to read some more right now preemptively.
+  if (!state.reading && !state.ending && !state.ended &&
+      state.length < state.highWaterMark) {
+    stream.read(0);
+  }
 }
 
 // abstract method.  to be overridden in specific implementation classes.
diff --git a/test/simple/test-stream-big-push.js b/test/simple/test-stream-big-push.js
new file mode 100644
index 00000000000..f54bcc30d38
--- /dev/null
+++ b/test/simple/test-stream-big-push.js
@@ -0,0 +1,84 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+var common = require('../common');
+var assert = require('assert');
+var stream = require('stream');
+var str = 'asdfasdfasdfasdfasdf';
+
+var r = new stream.Readable({
+  highWaterMark: 5,
+  encoding: 'utf8'
+});
+
+var reads = 0;
+var eofed = false;
+var ended = false;
+
+r._read = function(n, cb) {
+  if (reads === 0) {
+    setTimeout(function() {
+      cb(null, str);
+    });
+    reads++;
+  } else if (reads === 1) {
+    var ret = r.push(str);
+    assert.equal(ret, false);
+    reads++;
+  } else {
+    assert(!eofed);
+    eofed = true;
+    cb(null, null);
+  }
+};
+
+r.on('end', function() {
+  ended = true;
+});
+
+// push some data in to start.
+// we've never gotten any read event at this point.
+var ret = r.push(str);
+// should be false.  > hwm
+assert(!ret);
+var chunk = r.read();
+assert.equal(chunk, str);
+chunk = r.read();
+assert.equal(chunk, null);
+
+r.once('readable', function() {
+  // this time, we'll get *all* the remaining data, because
+  // it's been added synchronously, as the read WOULD take
+  // us below the hwm, and so it triggered a _read() again,
+  // which synchronously added more, which we then return.
+  chunk = r.read();
+  assert.equal(chunk, str + str);
+
+  chunk = r.read();
+  assert.equal(chunk, null);
+});
+
+process.on('exit', function() {
+  assert(eofed);
+  assert(ended);
+  assert.equal(reads, 2);
+  console.log('ok');
+});