diff --git a/qa/README.md b/qa/README.md
index c7e574ff70..7489eb5130 100644
--- a/qa/README.md
+++ b/qa/README.md
@@ -35,6 +35,9 @@ Run all possible tests with
 
     qa/pull-tester/rpc-tests.py -extended
 
+By default, tests will be run in parallel if you want to specify how many
+tests should be run in parallel, append `-paralell=n` (default n=4).
+
 If you want to create a basic coverage report for the rpc test suite, append `--coverage`.
 
 Possible options, which apply to each individual test run:
diff --git a/qa/pull-tester/rpc-tests.py b/qa/pull-tester/rpc-tests.py
index 10c3799b86..f810f89a59 100755
--- a/qa/pull-tester/rpc-tests.py
+++ b/qa/pull-tester/rpc-tests.py
@@ -53,10 +53,12 @@ ENABLE_COVERAGE=0
 
 #Create a set to store arguments and create the passon string
 opts = set()
-passon_args = ""
+passon_args = []
 PASSON_REGEX = re.compile("^--")
+PARALLEL_REGEX = re.compile('^-parallel=')
 
 print_help = False
+run_parallel = 4
 
 for arg in sys.argv[1:]:
     if arg == "--help" or arg == "-h" or arg == "-?":
@@ -65,7 +67,9 @@ for arg in sys.argv[1:]:
     if arg == '--coverage':
         ENABLE_COVERAGE = 1
     elif PASSON_REGEX.match(arg):
-        passon_args += " " + arg
+        passon_args.append(arg)
+    elif PARALLEL_REGEX.match(arg):
+        run_parallel = int(arg.split(sep='=', maxsplit=1)[1])
     else:
         opts.add(arg)
 
@@ -96,6 +100,7 @@ if ENABLE_ZMQ:
 
 #Tests
 testScripts = [
+    'walletbackup.py',
     'bip68-112-113-p2p.py',
     'wallet.py',
     'listtransactions.py',
@@ -116,7 +121,6 @@ testScripts = [
     'merkle_blocks.py',
     'fundrawtransaction.py',
     'signrawtransactions.py',
-    'walletbackup.py',
     'nodehandling.py',
     'reindex.py',
     'decodescript.py',
@@ -131,7 +135,7 @@ testScripts = [
     'abandonconflict.py',
     'p2p-versionbits-warning.py',
     'importprunedfunds.py',
-    'signmessages.py'
+    'signmessages.py',
 ]
 if ENABLE_ZMQ:
     testScripts.append('zmq_test.py')
@@ -160,6 +164,7 @@ testScriptsExt = [
     'pruning.py', # leave pruning last as it takes a REALLY long time
 ]
 
+
 def runtests():
     test_list = []
     if '-extended' in opts:
@@ -173,7 +178,7 @@ def runtests():
 
     if print_help:
         # Only print help of the first script and exit
-        subprocess.check_call(RPC_TESTS_DIR + test_list[0] + ' -h', shell=True)
+        subprocess.check_call((RPC_TESTS_DIR + test_list[0]).split() + ['-h'])
         sys.exit(0)
 
     coverage = None
@@ -181,15 +186,34 @@ def runtests():
     if ENABLE_COVERAGE:
         coverage = RPCCoverage()
         print("Initializing coverage directory at %s\n" % coverage.dir)
-    flags = " --srcdir %s/src %s %s" % (BUILDDIR, coverage.flag if coverage else '', passon_args)
+    flags = ["--srcdir=%s/src" % BUILDDIR] + passon_args
+    if coverage:
+        flags.append(coverage.flag)
+
+    if len(test_list) > 1:
+        # Populate cache
+        subprocess.check_output([RPC_TESTS_DIR + 'create_cache.py'] + flags)
 
     #Run Tests
-    for t in test_list:
-            print("Running testscript %s%s%s ..." % (BOLD[1], t, BOLD[0]))
-            time0 = time.time()
-            subprocess.check_call(
-                RPC_TESTS_DIR + t + flags, shell=True)
-            print("Duration: %s s\n" % (int(time.time() - time0)))
+    max_len_name = len(max(test_list, key=len))
+    time_sum = 0
+    time0 = time.time()
+    job_queue = RPCTestHandler(run_parallel, test_list, flags)
+    results = BOLD[1] + "%s | %s | %s\n\n" % ("TEST".ljust(max_len_name), "PASSED", "DURATION") + BOLD[0]
+    all_passed = True
+    for _ in range(len(test_list)):
+        (name, stdout, stderr, passed, duration) = job_queue.get_next()
+        all_passed = all_passed and passed
+        time_sum += duration
+
+        print('\n' + BOLD[1] + name + BOLD[0] + ":")
+        print(stdout)
+        print('stderr:\n' if not stderr == '' else '', stderr)
+        results += "%s | %s | %s s\n" % (name.ljust(max_len_name), str(passed).ljust(6), duration)
+        print("Pass: %s%s%s, Duration: %s s\n" % (BOLD[1], passed, BOLD[0], duration))
+    results += BOLD[1] + "\n%s | %s | %s s (accumulated)" % ("ALL".ljust(max_len_name), str(all_passed).ljust(6), time_sum) + BOLD[0]
+    print(results)
+    print("\nRuntime: %s s" % (int(time.time() - time0)))
 
     if coverage:
         coverage.report_rpc_coverage()
@@ -197,6 +221,49 @@ def runtests():
         print("Cleaning up coverage data")
         coverage.cleanup()
 
+    sys.exit(not all_passed)
+
+
+class RPCTestHandler:
+    """
+    Trigger the testscrips passed in via the list.
+    """
+
+    def __init__(self, num_tests_parallel, test_list=None, flags=None):
+        assert(num_tests_parallel >= 1)
+        self.num_jobs = num_tests_parallel
+        self.test_list = test_list
+        self.flags = flags
+        self.num_running = 0
+        self.jobs = []
+
+    def get_next(self):
+        while self.num_running < self.num_jobs and self.test_list:
+            # Add tests
+            self.num_running += 1
+            t = self.test_list.pop(0)
+            port_seed = ["--portseed=%s" % len(self.test_list)]
+            self.jobs.append((t,
+                              time.time(),
+                              subprocess.Popen((RPC_TESTS_DIR + t).split() + self.flags + port_seed,
+                                               universal_newlines=True,
+                                               stdout=subprocess.PIPE,
+                                               stderr=subprocess.PIPE)))
+        if not self.jobs:
+            raise IndexError('%s from empty list' % __name__)
+        while True:
+            # Return first proc that finishes
+            time.sleep(.5)
+            for j in self.jobs:
+                (name, time0, proc) = j
+                if proc.poll() is not None:
+                    (stdout, stderr) = proc.communicate(timeout=3)
+                    passed = stderr == "" and proc.returncode == 0
+                    self.num_running -= 1
+                    self.jobs.remove(j)
+                    return name, stdout, stderr, passed, int(time.time() - time0)
+            print('.', end='', flush=True)
+
 
 class RPCCoverage(object):
     """
@@ -215,7 +282,7 @@ class RPCCoverage(object):
     """
     def __init__(self):
         self.dir = tempfile.mkdtemp(prefix="coverage")
-        self.flag = '--coveragedir %s' % self.dir
+        self.flag = '--coveragedir=%s' % self.dir
 
     def report_rpc_coverage(self):
         """
diff --git a/qa/rpc-tests/create_cache.py b/qa/rpc-tests/create_cache.py
new file mode 100755
index 0000000000..b6161e0917
--- /dev/null
+++ b/qa/rpc-tests/create_cache.py
@@ -0,0 +1,23 @@
+#!/usr/bin/env python3
+# Copyright (c) 2016 The Bitcoin Core developers
+# Distributed under the MIT software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#
+# Helper script to create the cache
+# (see BitcoinTestFramework.setup_chain)
+#
+
+from test_framework.test_framework import BitcoinTestFramework
+
+class CreateCache(BitcoinTestFramework):
+
+    def setup_network(self):
+        # Don't setup any test nodes
+        self.options.noshutdown = True
+
+    def run_test(self):
+        pass
+
+if __name__ == '__main__':
+    CreateCache().main()
diff --git a/qa/rpc-tests/test_framework/test_framework.py b/qa/rpc-tests/test_framework/test_framework.py
index 4e72463096..3480de6c6e 100755
--- a/qa/rpc-tests/test_framework/test_framework.py
+++ b/qa/rpc-tests/test_framework/test_framework.py
@@ -5,10 +5,10 @@
 
 # Base class for RPC testing
 
-# Add python-bitcoinrpc to module search path:
+import logging
+import optparse
 import os
 import sys
-
 import shutil
 import tempfile
 import traceback
@@ -25,8 +25,9 @@ from .util import (
     enable_coverage,
     check_json_precision,
     initialize_chain_clean,
+    PortSeed,
 )
-from .authproxy import AuthServiceProxy, JSONRPCException
+from .authproxy import JSONRPCException
 
 
 class BitcoinTestFramework(object):
@@ -95,7 +96,6 @@ class BitcoinTestFramework(object):
         self.setup_network(False)
 
     def main(self):
-        import optparse
 
         parser = optparse.OptionParser(usage="%prog [options]")
         parser.add_option("--nocleanup", dest="nocleanup", default=False, action="store_true",
@@ -108,18 +108,21 @@ class BitcoinTestFramework(object):
                           help="Root directory for datadirs")
         parser.add_option("--tracerpc", dest="trace_rpc", default=False, action="store_true",
                           help="Print out all RPC calls as they are made")
+        parser.add_option("--portseed", dest="port_seed", default=os.getpid(), type='int',
+                          help="The seed to use for assigning port numbers (default: current process id)")
         parser.add_option("--coveragedir", dest="coveragedir",
                           help="Write tested RPC commands into this directory")
         self.add_options(parser)
         (self.options, self.args) = parser.parse_args()
 
         if self.options.trace_rpc:
-            import logging
             logging.basicConfig(level=logging.DEBUG, stream=sys.stdout)
 
         if self.options.coveragedir:
             enable_coverage(self.options.coveragedir)
 
+        PortSeed.n = self.options.port_seed
+
         os.environ['PATH'] = self.options.srcdir+":"+self.options.srcdir+"/qt:"+os.environ['PATH']
 
         check_json_precision()
diff --git a/qa/rpc-tests/test_framework/util.py b/qa/rpc-tests/test_framework/util.py
index 6dc685ea1b..6784177aaa 100644
--- a/qa/rpc-tests/test_framework/util.py
+++ b/qa/rpc-tests/test_framework/util.py
@@ -8,7 +8,6 @@
 # Helpful routines for regression testing
 #
 
-# Add python-bitcoinrpc to module search path:
 import os
 import sys
 
@@ -36,6 +35,11 @@ PORT_MIN = 11000
 # The number of ports to "reserve" for p2p and rpc, each
 PORT_RANGE = 5000
 
+
+class PortSeed:
+    # Must be initialized with a unique integer for each process
+    n = None
+
 #Set Mocktime default to OFF.
 #MOCKTIME is only needed for scripts that use the
 #cached version of the blockchain.  If the cached
@@ -91,10 +95,10 @@ def get_rpc_proxy(url, node_number, timeout=None):
 
 def p2p_port(n):
     assert(n <= MAX_NODES)
-    return PORT_MIN + n + (MAX_NODES * os.getpid()) % (PORT_RANGE - 1 - MAX_NODES)
+    return PORT_MIN + n + (MAX_NODES * PortSeed.n) % (PORT_RANGE - 1 - MAX_NODES)
 
 def rpc_port(n):
-    return PORT_MIN + PORT_RANGE + n + (MAX_NODES * os.getpid()) % (PORT_RANGE -1 - MAX_NODES)
+    return PORT_MIN + PORT_RANGE + n + (MAX_NODES * PortSeed.n) % (PORT_RANGE - 1 - MAX_NODES)
 
 def check_json_precision():
     """Make sure json library being used does not lose precision converting BTC values"""