diff --git a/qa/rpc-tests/decodescript.py b/qa/rpc-tests/decodescript.py
index ce3bc94ef..89364a840 100755
--- a/qa/rpc-tests/decodescript.py
+++ b/qa/rpc-tests/decodescript.py
@@ -4,7 +4,9 @@
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 from test_framework.test_framework import BitcoinTestFramework
-from test_framework.util import *
+from test_framework.util import assert_equal, initialize_chain_clean, \
+    start_nodes
+
 
 class DecodeScriptTest(BitcoinTestFramework):
     """Tests decoding scripts via RPC command "decodescript"."""
diff --git a/qa/rpc-tests/disablewallet.py b/qa/rpc-tests/disablewallet.py
index 67acdcea1..339c6a8f6 100755
--- a/qa/rpc-tests/disablewallet.py
+++ b/qa/rpc-tests/disablewallet.py
@@ -8,7 +8,8 @@
 #
 
 from test_framework.test_framework import BitcoinTestFramework
-from test_framework.util import *
+from test_framework.util import initialize_chain_clean, start_nodes
+
 
 class DisableWalletTest (BitcoinTestFramework):
 
diff --git a/qa/rpc-tests/forknotify.py b/qa/rpc-tests/forknotify.py
index 0acef8e30..1be750a64 100755
--- a/qa/rpc-tests/forknotify.py
+++ b/qa/rpc-tests/forknotify.py
@@ -8,9 +8,9 @@
 #
 
 from test_framework.test_framework import BitcoinTestFramework
-from test_framework.util import *
+from test_framework.util import start_node, connect_nodes
+
 import os
-import shutil
 
 class ForkNotifyTest(BitcoinTestFramework):
 
@@ -19,7 +19,7 @@ class ForkNotifyTest(BitcoinTestFramework):
     def setup_network(self):
         self.nodes = []
         self.alert_filename = os.path.join(self.options.tmpdir, "alert.txt")
-        with open(self.alert_filename, 'w') as f:
+        with open(self.alert_filename, 'w'):
             pass  # Just open then close to create zero-length file
         self.nodes.append(start_node(0, self.options.tmpdir,
                             ["-blockversion=2", "-alertnotify=echo %s >> \"" + self.alert_filename + "\""]))
diff --git a/qa/rpc-tests/fundrawtransaction.py b/qa/rpc-tests/fundrawtransaction.py
index 1d15fd132..42896be4f 100755
--- a/qa/rpc-tests/fundrawtransaction.py
+++ b/qa/rpc-tests/fundrawtransaction.py
@@ -4,9 +4,12 @@
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 from test_framework.test_framework import BitcoinTestFramework
-from test_framework.util import *
-from pprint import pprint
-from time import sleep
+from test_framework.authproxy import JSONRPCException
+from test_framework.util import assert_equal, assert_greater_than, \
+    initialize_chain_clean, start_nodes, connect_nodes_bi, stop_nodes, \
+    wait_bitcoinds
+
+from decimal import Decimal
 
 # Create one-input, one-output, no-fee transaction:
 class RawTransactionsTest(BitcoinTestFramework):
diff --git a/qa/rpc-tests/getblocktemplate.py b/qa/rpc-tests/getblocktemplate.py
index c9777c0c7..82082afa9 100755
--- a/qa/rpc-tests/getblocktemplate.py
+++ b/qa/rpc-tests/getblocktemplate.py
@@ -4,7 +4,8 @@
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 from test_framework.test_framework import BitcoinTestFramework
-from test_framework.util import *
+from test_framework.util import initialize_chain_clean, start_nodes, \
+    connect_nodes_bi
 
 
 class GetBlockTemplateTest(BitcoinTestFramework):
diff --git a/qa/rpc-tests/getblocktemplate_longpoll.py b/qa/rpc-tests/getblocktemplate_longpoll.py
index aab456242..37a40384b 100755
--- a/qa/rpc-tests/getblocktemplate_longpoll.py
+++ b/qa/rpc-tests/getblocktemplate_longpoll.py
@@ -4,8 +4,10 @@
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 from test_framework.test_framework import BitcoinTestFramework
-from test_framework.util import *
+from test_framework.authproxy import AuthServiceProxy
+from test_framework.util import random_transaction
 
+from decimal import Decimal
 
 def check_array_result(object_array, to_match, expected):
     """
diff --git a/qa/rpc-tests/getblocktemplate_proposals.py b/qa/rpc-tests/getblocktemplate_proposals.py
index 0c9e7e4cc..16b2e9b94 100755
--- a/qa/rpc-tests/getblocktemplate_proposals.py
+++ b/qa/rpc-tests/getblocktemplate_proposals.py
@@ -4,7 +4,7 @@
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 from test_framework.test_framework import BitcoinTestFramework
-from test_framework.util import *
+from test_framework.authproxy import JSONRPCException
 
 from binascii import a2b_hex, b2a_hex
 from hashlib import sha256
diff --git a/qa/rpc-tests/hardforkdetection.py b/qa/rpc-tests/hardforkdetection.py
index d399dc964..dbfb5cd34 100755
--- a/qa/rpc-tests/hardforkdetection.py
+++ b/qa/rpc-tests/hardforkdetection.py
@@ -5,9 +5,10 @@
 #
 
 from test_framework.test_framework import BitcoinTestFramework
-from test_framework.util import *
+from test_framework.authproxy import JSONRPCException
+from test_framework.util import assert_equal, start_node
+
 import os
-import shutil
 
 class HardForkDetectionTest(BitcoinTestFramework):
 
@@ -16,7 +17,7 @@ class HardForkDetectionTest(BitcoinTestFramework):
     def setup_network(self):
         self.nodes = []
         self.alert_filename = os.path.join(self.options.tmpdir, "alert.txt")
-        with open(self.alert_filename, 'w') as f:
+        with open(self.alert_filename, 'w'):
             pass  # Just open then close to create zero-length file
         self.nodes.append(start_node(0, self.options.tmpdir,
                             ["-blockversion=2", "-alertnotify=echo %s >> \"" + self.alert_filename + "\""]))
diff --git a/qa/rpc-tests/httpbasics.py b/qa/rpc-tests/httpbasics.py
index b66533543..b1a4623bd 100755
--- a/qa/rpc-tests/httpbasics.py
+++ b/qa/rpc-tests/httpbasics.py
@@ -8,7 +8,8 @@
 #
 
 from test_framework.test_framework import BitcoinTestFramework
-from test_framework.util import *
+from test_framework.util import assert_equal, start_nodes
+
 import base64
 
 try:
@@ -36,45 +37,45 @@ class HTTPBasicsTest (BitcoinTestFramework):
         conn = httplib.HTTPConnection(url.hostname, url.port)
         conn.connect()
         conn.request('POST', '/', '{"method": "getbestblockhash"}', headers)
-        out1 = conn.getresponse().read();
+        out1 = conn.getresponse().read()
         assert_equal('"error":null' in out1, True)
-        assert_equal(conn.sock!=None, True) #according to http/1.1 connection must still be open!
+        assert_equal(conn.sock!=None, True) # according to http/1.1 connection must still be open!
 
-        #send 2nd request without closing connection
+        # send 2nd request without closing connection
         conn.request('POST', '/', '{"method": "getchaintips"}', headers)
-        out2 = conn.getresponse().read();
-        assert_equal('"error":null' in out1, True) #must also response with a correct json-rpc message
-        assert_equal(conn.sock!=None, True) #according to http/1.1 connection must still be open!
+        out2 = conn.getresponse().read()
+        assert_equal('"error":null' in out2, True) # must also response with a correct json-rpc message
+        assert_equal(conn.sock!=None, True) # according to http/1.1 connection must still be open!
         conn.close()
 
-        #same should be if we add keep-alive because this should be the std. behaviour
+        # same should be if we add keep-alive because this should be the std. behaviour
         headers = {"Authorization": "Basic " + base64.b64encode(authpair), "Connection": "keep-alive"}
 
         conn = httplib.HTTPConnection(url.hostname, url.port)
         conn.connect()
         conn.request('POST', '/', '{"method": "getbestblockhash"}', headers)
-        out1 = conn.getresponse().read();
+        out1 = conn.getresponse().read()
         assert_equal('"error":null' in out1, True)
-        assert_equal(conn.sock!=None, True) #according to http/1.1 connection must still be open!
+        assert_equal(conn.sock!=None, True) # according to http/1.1 connection must still be open!
 
-        #send 2nd request without closing connection
+        # send 2nd request without closing connection
         conn.request('POST', '/', '{"method": "getchaintips"}', headers)
-        out2 = conn.getresponse().read();
-        assert_equal('"error":null' in out1, True) #must also response with a correct json-rpc message
-        assert_equal(conn.sock!=None, True) #according to http/1.1 connection must still be open!
+        out2 = conn.getresponse().read()
+        assert_equal('"error":null' in out2, True) # must also response with a correct json-rpc message
+        assert_equal(conn.sock!=None, True) # according to http/1.1 connection must still be open!
         conn.close()
 
-        #now do the same with "Connection: close"
+        # now do the same with "Connection: close"
         headers = {"Authorization": "Basic " + base64.b64encode(authpair), "Connection":"close"}
 
         conn = httplib.HTTPConnection(url.hostname, url.port)
         conn.connect()
         conn.request('POST', '/', '{"method": "getbestblockhash"}', headers)
-        out1 = conn.getresponse().read();
+        out1 = conn.getresponse().read()
         assert_equal('"error":null' in out1, True)
-        assert_equal(conn.sock!=None, False) #now the connection must be closed after the response
+        assert_equal(conn.sock!=None, False) # now the connection must be closed after the response
 
-        #node1 (2nd node) is running with disabled keep-alive option
+        # node1 (2nd node) is running with disabled keep-alive option
         urlNode1 = urlparse.urlparse(self.nodes[1].url)
         authpair = urlNode1.username + ':' + urlNode1.password
         headers = {"Authorization": "Basic " + base64.b64encode(authpair)}
@@ -82,10 +83,10 @@ class HTTPBasicsTest (BitcoinTestFramework):
         conn = httplib.HTTPConnection(urlNode1.hostname, urlNode1.port)
         conn.connect()
         conn.request('POST', '/', '{"method": "getbestblockhash"}', headers)
-        out1 = conn.getresponse().read();
+        out1 = conn.getresponse().read()
         assert_equal('"error":null' in out1, True)
 
-        #node2 (third node) is running with standard keep-alive parameters which means keep-alive is on
+        # node2 (third node) is running with standard keep-alive parameters which means keep-alive is on
         urlNode2 = urlparse.urlparse(self.nodes[2].url)
         authpair = urlNode2.username + ':' + urlNode2.password
         headers = {"Authorization": "Basic " + base64.b64encode(authpair)}
@@ -93,9 +94,9 @@ class HTTPBasicsTest (BitcoinTestFramework):
         conn = httplib.HTTPConnection(urlNode2.hostname, urlNode2.port)
         conn.connect()
         conn.request('POST', '/', '{"method": "getbestblockhash"}', headers)
-        out1 = conn.getresponse().read();
+        out1 = conn.getresponse().read()
         assert_equal('"error":null' in out1, True)
-        assert_equal(conn.sock!=None, True) #connection must be closed because bitcoind should use keep-alive by default
+        assert_equal(conn.sock!=None, True) # connection must be closed because bitcoind should use keep-alive by default
 
 if __name__ == '__main__':
-    HTTPBasicsTest ().main ()
+    HTTPBasicsTest().main()
diff --git a/qa/rpc-tests/invalidateblock.py b/qa/rpc-tests/invalidateblock.py
index 2b9c8154e..5cbd1ea98 100755
--- a/qa/rpc-tests/invalidateblock.py
+++ b/qa/rpc-tests/invalidateblock.py
@@ -8,22 +8,23 @@
 #
 
 from test_framework.test_framework import BitcoinTestFramework
-from test_framework.util import *
+from test_framework.util import initialize_chain_clean, start_node, \
+    connect_nodes_bi, sync_blocks
+
+import time
 
 class InvalidateTest(BitcoinTestFramework):
-    
-        
     def setup_chain(self):
         print("Initializing test directory "+self.options.tmpdir)
         initialize_chain_clean(self.options.tmpdir, 3)
-                 
+
     def setup_network(self):
         self.nodes = []
-        self.is_network_split = False 
+        self.is_network_split = False
         self.nodes.append(start_node(0, self.options.tmpdir, ["-debug"]))
         self.nodes.append(start_node(1, self.options.tmpdir, ["-debug"]))
         self.nodes.append(start_node(2, self.options.tmpdir, ["-debug"]))
-        
+
     def run_test(self):
         print "Make sure we repopulate setBlockIndexCandidates after InvalidateBlock:"
         print "Mine 4 blocks on Node 0"
diff --git a/qa/rpc-tests/invalidblockrequest.py b/qa/rpc-tests/invalidblockrequest.py
index 272cc08f9..05b33d772 100755
--- a/qa/rpc-tests/invalidblockrequest.py
+++ b/qa/rpc-tests/invalidblockrequest.py
@@ -5,11 +5,11 @@
 #
 
 from test_framework.test_framework import ComparisonTestFramework
-from test_framework.util import *
+from test_framework.util import assert_equal
 from test_framework.comptool import TestManager, TestInstance
-from test_framework.mininode import *
-from test_framework.blocktools import *
-import logging
+from test_framework.mininode import NetworkThread
+from test_framework.blocktools import create_block, create_coinbase, create_transaction
+
 import copy
 import time
 
@@ -25,7 +25,7 @@ re-requested.
 # Use the ComparisonTestFramework with 1 node: only use --testbinary.
 class InvalidBlockRequestTest(ComparisonTestFramework):
 
-    ''' Can either run this test as 1 node with expected answers, or two and compare them. 
+    ''' Can either run this test as 1 node with expected answers, or two and compare them.
         Change the "outcome" variable from each TestInstance object to only do the comparison. '''
     def __init__(self):
         self.num_nodes = 1
diff --git a/qa/rpc-tests/keypool.py b/qa/rpc-tests/keypool.py
index 38d6874dc..a7b32e13f 100755
--- a/qa/rpc-tests/keypool.py
+++ b/qa/rpc-tests/keypool.py
@@ -6,18 +6,17 @@
 # Exercise the wallet keypool, and interaction with wallet encryption/locking
 
 # Add python-bitcoinrpc to module search path:
+
+from test_framework.authproxy import JSONRPCException
+from test_framework.util import check_json_precision, initialize_chain, \
+    start_nodes, start_node, stop_nodes, wait_bitcoinds, bitcoind_processes
+
 import os
 import sys
-
-import json
 import shutil
-import subprocess
 import tempfile
 import traceback
 
-from test_framework.util import *
-
-
 def check_array_result(object_array, to_match, expected):
     """
     Pass in array of JSON objects, a dictionary with key/value pairs
diff --git a/qa/rpc-tests/listtransactions.py b/qa/rpc-tests/listtransactions.py
index 4df8d795d..a735f41ab 100755
--- a/qa/rpc-tests/listtransactions.py
+++ b/qa/rpc-tests/listtransactions.py
@@ -6,8 +6,8 @@
 # Exercise the listtransactions API
 
 from test_framework.test_framework import BitcoinTestFramework
-from test_framework.util import *
 
+from decimal import Decimal
 
 def check_array_result(object_array, to_match, expected):
     """
diff --git a/qa/rpc-tests/maxblocksinflight.py b/qa/rpc-tests/maxblocksinflight.py
index a601147ce..beef3d2ea 100755
--- a/qa/rpc-tests/maxblocksinflight.py
+++ b/qa/rpc-tests/maxblocksinflight.py
@@ -4,9 +4,15 @@
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 #
 
-from test_framework.mininode import *
+from test_framework.mininode import NodeConn, NodeConnCB, NetworkThread, \
+    EarlyDisconnectError, CInv, msg_inv, mininode_lock
 from test_framework.test_framework import BitcoinTestFramework
-from test_framework.util import *
+from test_framework.util import initialize_chain_clean, start_nodes, \
+    p2p_port
+
+import os
+import time
+import random
 import logging
 
 '''
@@ -43,7 +49,6 @@ class TestManager(NodeConnCB):
 
     def run(self):
         try:
-            fail = False
             self.connection.rpc.generate(1) # Leave IBD
 
             numBlocksToGenerate = [ 8, 16, 128, 1024 ]
@@ -56,7 +61,7 @@ class TestManager(NodeConnCB):
                         current_invs = []
                 if len(current_invs) > 0:
                     self.connection.send_message(msg_inv(current_invs))
-                
+
                 # Wait and see how many blocks were requested
                 time.sleep(2)
 
@@ -75,7 +80,7 @@ class TestManager(NodeConnCB):
         self.disconnectOkay = True
         self.connection.disconnect_node()
 
-        
+
 class MaxBlocksInFlightTest(BitcoinTestFramework):
     def add_options(self, parser):
         parser.add_option("--testbinary", dest="testbinary",
diff --git a/qa/rpc-tests/mempool_coinbase_spends.py b/qa/rpc-tests/mempool_coinbase_spends.py
index 578ddb1fb..041de831b 100755
--- a/qa/rpc-tests/mempool_coinbase_spends.py
+++ b/qa/rpc-tests/mempool_coinbase_spends.py
@@ -9,9 +9,8 @@
 #
 
 from test_framework.test_framework import BitcoinTestFramework
-from test_framework.util import *
-import os
-import shutil
+from test_framework.util import assert_equal, start_node, connect_nodes
+
 
 # Create one-input, one-output, no-fee transaction:
 class MempoolCoinbaseTest(BitcoinTestFramework):
@@ -36,8 +35,6 @@ class MempoolCoinbaseTest(BitcoinTestFramework):
         return signresult["hex"]
 
     def run_test(self):
-        start_count = self.nodes[0].getblockcount()
-
         # Mine three blocks. After this, nodes[0] blocks
         # 101, 102, and 103 are spend-able.
         new_blocks = self.nodes[1].generate(4)
@@ -69,6 +66,7 @@ class MempoolCoinbaseTest(BitcoinTestFramework):
 
         # Broadcast and mine 103_1:
         spend_103_1_id = self.nodes[0].sendrawtransaction(spend_103_1_raw)
+        [spend_103_1_id] # hush pyflakes
         self.nodes[0].generate(1)
 
         # ... now put spend_101 and spend_102_1 in memory pools:
diff --git a/qa/rpc-tests/mempool_resurrect_test.py b/qa/rpc-tests/mempool_resurrect_test.py
index dd3f0486f..1cbbd2cd5 100755
--- a/qa/rpc-tests/mempool_resurrect_test.py
+++ b/qa/rpc-tests/mempool_resurrect_test.py
@@ -9,9 +9,8 @@
 #
 
 from test_framework.test_framework import BitcoinTestFramework
-from test_framework.util import *
-import os
-import shutil
+from test_framework.util import assert_equal, start_node
+
 
 # Create one-input, one-output, no-fee transaction:
 class MempoolCoinbaseTest(BitcoinTestFramework):
diff --git a/qa/rpc-tests/mempool_spendcoinbase.py b/qa/rpc-tests/mempool_spendcoinbase.py
index b2ec6937b..5366fb955 100755
--- a/qa/rpc-tests/mempool_spendcoinbase.py
+++ b/qa/rpc-tests/mempool_spendcoinbase.py
@@ -14,9 +14,10 @@
 #
 
 from test_framework.test_framework import BitcoinTestFramework
-from test_framework.util import *
-import os
-import shutil
+from test_framework.authproxy import JSONRPCException
+from test_framework.util import assert_equal, assert_greater_than, assert_raises, \
+    start_node
+
 
 # Create one-input, one-output, no-fee transaction:
 class MempoolSpendCoinbaseTest(BitcoinTestFramework):
diff --git a/qa/rpc-tests/mempool_tx_input_limit.py b/qa/rpc-tests/mempool_tx_input_limit.py
index 89a96a0ca..538122671 100755
--- a/qa/rpc-tests/mempool_tx_input_limit.py
+++ b/qa/rpc-tests/mempool_tx_input_limit.py
@@ -4,10 +4,12 @@
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 from test_framework.test_framework import BitcoinTestFramework
-from test_framework.util import *
-import os
-import shutil
-from time import sleep
+from test_framework.authproxy import JSONRPCException
+from test_framework.util import assert_equal, initialize_chain_clean, \
+    start_node, connect_nodes
+
+import time
+from decimal import Decimal
 
 # Test -mempooltxinputlimit
 class MempoolTxInputLimitTest(BitcoinTestFramework):
@@ -44,7 +46,7 @@ class MempoolTxInputLimitTest(BitcoinTestFramework):
         for x in xrange(1, timeout):
             results = self.nodes[0].z_getoperationresult(opids)
             if len(results)==0:
-                sleep(1)
+                time.sleep(1)
             else:
                 status = results[0]["status"]
                 if status == "failed":
@@ -61,8 +63,6 @@ class MempoolTxInputLimitTest(BitcoinTestFramework):
         return txid
 
     def run_test(self):
-        start_count = self.nodes[0].getblockcount()
-
         self.nodes[0].generate(100)
         self.sync_all()
         # Mine three blocks. After this, nodes[0] blocks
@@ -90,7 +90,7 @@ class MempoolTxInputLimitTest(BitcoinTestFramework):
         for x in xrange(1, timeout):
             results = self.nodes[0].z_getoperationresult(opids)
             if len(results)==0:
-                sleep(1)
+                time.sleep(1)
             else:
                 status = results[0]["status"]
                 msg = results[0]["error"]["message"]
@@ -116,7 +116,6 @@ class MempoolTxInputLimitTest(BitcoinTestFramework):
         assert_equal(set(self.nodes[0].getrawmempool()), set())
 
         # Check 2: sendfrom is limited by -mempooltxinputlimit
-        node1_taddr = self.nodes[1].getnewaddress();
         recipients = []
         spend_taddr_amount = spend_zaddr_amount - Decimal('0.0001')
         spend_taddr_output = Decimal('8')
diff --git a/qa/rpc-tests/merkle_blocks.py b/qa/rpc-tests/merkle_blocks.py
index 5c333124f..2c0fcd203 100755
--- a/qa/rpc-tests/merkle_blocks.py
+++ b/qa/rpc-tests/merkle_blocks.py
@@ -8,9 +8,10 @@
 #
 
 from test_framework.test_framework import BitcoinTestFramework
-from test_framework.util import *
-import os
-import shutil
+from test_framework.authproxy import JSONRPCException
+from test_framework.util import assert_equal, assert_raises, \
+    initialize_chain_clean, start_node, connect_nodes
+
 
 class MerkleBlockTest(BitcoinTestFramework):
 
diff --git a/qa/rpc-tests/nodehandling.py b/qa/rpc-tests/nodehandling.py
index 9a77bd97e..391a935d0 100755
--- a/qa/rpc-tests/nodehandling.py
+++ b/qa/rpc-tests/nodehandling.py
@@ -8,13 +8,10 @@
 #
 
 from test_framework.test_framework import BitcoinTestFramework
-from test_framework.util import *
-import base64
+from test_framework.util import assert_equal, connect_nodes_bi, p2p_port
+
+import time
 
-try:
-    import http.client as httplib
-except ImportError:
-    import httplib
 try:
     import urllib.parse as urlparse
 except ImportError:
diff --git a/qa/rpc-tests/p2p-acceptblock.py b/qa/rpc-tests/p2p-acceptblock.py
index 83c03eeb7..25221fbed 100755
--- a/qa/rpc-tests/p2p-acceptblock.py
+++ b/qa/rpc-tests/p2p-acceptblock.py
@@ -4,12 +4,17 @@
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 #
 
-from test_framework.mininode import *
+from test_framework.mininode import CBlockHeader, CInv, NodeConn, NodeConnCB, \
+    NetworkThread, msg_block, msg_headers, msg_inv, msg_ping, msg_pong, \
+    mininode_lock
 from test_framework.test_framework import BitcoinTestFramework
-from test_framework.util import *
-import time
+from test_framework.util import assert_equal, initialize_chain_clean, \
+    start_node, p2p_port
 from test_framework.blocktools import create_block, create_coinbase
 
+import os
+import time
+
 '''
 AcceptBlockTest -- test processing of unrequested blocks.
 
diff --git a/qa/rpc-tests/prioritisetransaction.py b/qa/rpc-tests/prioritisetransaction.py
index 19697fc4a..9eeb72e8c 100755
--- a/qa/rpc-tests/prioritisetransaction.py
+++ b/qa/rpc-tests/prioritisetransaction.py
@@ -4,9 +4,10 @@
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 from test_framework.test_framework import BitcoinTestFramework
-from test_framework.util import *
-from time import *
+from test_framework.util import assert_equal, initialize_chain_clean, \
+    start_node, connect_nodes
 from test_framework.mininode import COIN
+
 import time
 
 
@@ -37,7 +38,7 @@ class PrioritiseTransactionTest (BitcoinTestFramework):
         for x in xrange(1, timeout):
             results = self.nodes[0].z_getoperationresult(opids)
             if len(results)==0:
-                sleep(1)
+                time.sleep(1)
             else:
                 status = results[0]["status"]
                 if status == "failed":
@@ -120,7 +121,7 @@ class PrioritiseTransactionTest (BitcoinTestFramework):
                     break
             if time.time() - start > 30:
                 raise AssertionError("Test timed out because prioritised transaction was not returned by getblocktemplate within 30 seconds.")
-            sleep(1)
+            time.sleep(1)
             block_template = self.nodes[0].getblocktemplate()
 
         assert(in_block_template)
diff --git a/qa/rpc-tests/proton_test.py b/qa/rpc-tests/proton_test.py
index b895c087f..d9fb27bd3 100755
--- a/qa/rpc-tests/proton_test.py
+++ b/qa/rpc-tests/proton_test.py
@@ -14,21 +14,13 @@
 #
 
 from test_framework.test_framework import BitcoinTestFramework
-from test_framework.util import *
+from test_framework.util import assert_equal, bytes_to_hex_str, \
+    start_nodes
+
 from proton.handlers import MessagingHandler
 from proton.reactor import Container
-import binascii
-import struct
-import threading
 
-try:
-    import http.client as httplib
-except ImportError:
-    import httplib
-try:
-    import urllib.parse as urlparse
-except ImportError:
-    import urlparse
+import threading
 
 
 class Server(MessagingHandler):
diff --git a/qa/rpc-tests/proxy_test.py b/qa/rpc-tests/proxy_test.py
index 3623c1616..e4fb48820 100755
--- a/qa/rpc-tests/proxy_test.py
+++ b/qa/rpc-tests/proxy_test.py
@@ -2,14 +2,14 @@
 # Copyright (c) 2015 The Bitcoin Core developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
-import socket
-import traceback, sys
-from binascii import hexlify
-import time, os
 
 from test_framework.socks5 import Socks5Configuration, Socks5Command, Socks5Server, AddressType
 from test_framework.test_framework import BitcoinTestFramework
-from test_framework.util import *
+from test_framework.util import assert_equal, start_nodes
+
+import socket
+import os
+
 '''
 Test plan:
 - Start bitcoind's with different proxy configurations
diff --git a/qa/rpc-tests/pruning.py b/qa/rpc-tests/pruning.py
index 21f8d6938..2639060fa 100755
--- a/qa/rpc-tests/pruning.py
+++ b/qa/rpc-tests/pruning.py
@@ -12,8 +12,12 @@
 # ********
 
 from test_framework.test_framework import BitcoinTestFramework
-from test_framework.util import *
+from test_framework.authproxy import JSONRPCException
+from test_framework.util import initialize_chain_clean, start_node, \
+    connect_nodes, stop_node, sync_blocks
+
 import os.path
+import time
 
 def calc_usage(blockdir):
     return sum(os.path.getsize(blockdir+f) for f in os.listdir(blockdir) if os.path.isfile(blockdir+f))/(1024*1024)
@@ -190,7 +194,7 @@ class PruneTest(BitcoinTestFramework):
         try:
             self.nodes[2].getblock(self.forkhash)
             raise AssertionError("Old block wasn't pruned so can't test redownload")
-        except JSONRPCException as e:
+        except JSONRPCException:
             print "Will need to redownload block",self.forkheight
 
         # Verify that we have enough history to reorg back to the fork point
@@ -253,7 +257,7 @@ class PruneTest(BitcoinTestFramework):
             newtx = newtx + rawtx[94:]
             # Appears to be ever so slightly faster to sign with SIGHASH_NONE
             signresult = node.signrawtransaction(newtx,None,None,"NONE")
-            txid = node.sendrawtransaction(signresult["hex"], True)
+            node.sendrawtransaction(signresult["hex"], True)
         # Mine a full sized block which will be these transactions we just created
         node.generate(1)
 
diff --git a/qa/rpc-tests/rawtransactions.py b/qa/rpc-tests/rawtransactions.py
index 45517d3fd..dc919f028 100755
--- a/qa/rpc-tests/rawtransactions.py
+++ b/qa/rpc-tests/rawtransactions.py
@@ -9,9 +9,11 @@
 #
 
 from test_framework.test_framework import BitcoinTestFramework
-from test_framework.util import *
-from pprint import pprint
-from time import sleep
+from test_framework.authproxy import JSONRPCException
+from test_framework.util import assert_equal, initialize_chain_clean, \
+    start_nodes, connect_nodes_bi
+
+from decimal import Decimal
 
 # Create one-input, one-output, no-fee transaction:
 class RawTransactionsTest(BitcoinTestFramework):
@@ -104,18 +106,20 @@ class RawTransactionsTest(BitcoinTestFramework):
 
         mSigObj = self.nodes[2].addmultisigaddress(2, [addr1Obj['pubkey'], addr2Obj['pubkey'], addr3Obj['pubkey']])
         mSigObjValid = self.nodes[2].validateaddress(mSigObj)
+        assert_equal(mSigObjValid['isvalid'], True)
 
         txId       = self.nodes[0].sendtoaddress(mSigObj, 2.2);
         decTx = self.nodes[0].gettransaction(txId)
         rawTx = self.nodes[0].decoderawtransaction(decTx['hex'])
         sPK = rawTx['vout'][0]['scriptPubKey']['hex']
+        [sPK] # hush pyflakes
         self.sync_all()
         self.nodes[0].generate(1)
         self.sync_all()
 
-        #THIS IS A INCOMPLETE FEATURE
-        #NODE2 HAS TWO OF THREE KEY AND THE FUNDS SHOULD BE SPENDABLE AND COUNT AT BALANCE CALCULATION
-        assert_equal(self.nodes[2].getbalance(), bal) #for now, assume the funds of a 2of3 multisig tx are not marked as spendable
+        # THIS IS A INCOMPLETE FEATURE
+        # NODE2 HAS TWO OF THREE KEY AND THE FUNDS SHOULD BE SPENDABLE AND COUNT AT BALANCE CALCULATION
+        assert_equal(self.nodes[2].getbalance(), bal) # for now, assume the funds of a 2of3 multisig tx are not marked as spendable
 
         txDetails = self.nodes[0].gettransaction(txId, True)
         rawTx = self.nodes[0].decoderawtransaction(txDetails['hex'])
@@ -130,10 +134,10 @@ class RawTransactionsTest(BitcoinTestFramework):
         outputs = { self.nodes[0].getnewaddress() : 2.199 }
         rawTx = self.nodes[2].createrawtransaction(inputs, outputs)
         rawTxPartialSigned = self.nodes[1].signrawtransaction(rawTx, inputs)
-        assert_equal(rawTxPartialSigned['complete'], False) #node1 only has one key, can't comp. sign the tx
-        
+        assert_equal(rawTxPartialSigned['complete'], False) # node1 only has one key, can't comp. sign the tx
+
         rawTxSigned = self.nodes[2].signrawtransaction(rawTx, inputs)
-        assert_equal(rawTxSigned['complete'], True) #node2 can sign the tx compl., own two of three keys
+        assert_equal(rawTxSigned['complete'], True) # node2 can sign the tx compl., own two of three keys
         self.nodes[2].sendrawtransaction(rawTxSigned['hex'])
         rawTx = self.nodes[0].decoderawtransaction(rawTxSigned['hex'])
         self.sync_all()
diff --git a/qa/rpc-tests/receivedby.py b/qa/rpc-tests/receivedby.py
index 16d6bd4cf..59f7bf258 100755
--- a/qa/rpc-tests/receivedby.py
+++ b/qa/rpc-tests/receivedby.py
@@ -6,15 +6,14 @@
 # Exercise the listreceivedbyaddress API
 
 from test_framework.test_framework import BitcoinTestFramework
-from test_framework.util import *
 
+from decimal import Decimal
 
 def get_sub_array_from_array(object_array, to_match):
     '''
-        Finds and returns a sub array from an array of arrays.
-        to_match should be a unique idetifier of a sub array
+    Finds and returns a sub array from an array of arrays.
+    to_match should be a unique idetifier of a sub array
     '''
-    num_matched = 0
     for item in object_array:
         all_match = True
         for key,value in to_match.items():
@@ -26,12 +25,12 @@ def get_sub_array_from_array(object_array, to_match):
     return []
 
 def check_array_result(object_array, to_match, expected, should_not_find = False):
-    """
-        Pass in array of JSON objects, a dictionary with key/value pairs
-        to match against, and another dictionary with expected key/value
-        pairs.
-        If the should_not_find flag is true, to_match should not be found in object_array
-        """
+    '''
+    Pass in array of JSON objects, a dictionary with key/value pairs
+    to match against, and another dictionary with expected key/value
+    pairs.
+    If the should_not_find flag is true, to_match should not be found in object_array
+    '''
     if should_not_find == True:
         expected = { }
     num_matched = 0
@@ -62,49 +61,49 @@ class ReceivedByTest(BitcoinTestFramework):
         txid = self.nodes[0].sendtoaddress(addr, 0.1)
         self.sync_all()
 
-        #Check not listed in listreceivedbyaddress because has 0 confirmations
+        # Check not listed in listreceivedbyaddress because has 0 confirmations
         check_array_result(self.nodes[1].listreceivedbyaddress(),
                            {"address":addr},
                            { },
                            True)
-        #Bury Tx under 10 block so it will be returned by listreceivedbyaddress
+        # Bury Tx under 10 block so it will be returned by listreceivedbyaddress
         self.nodes[1].generate(10)
         self.sync_all()
         check_array_result(self.nodes[1].listreceivedbyaddress(),
                            {"address":addr},
                            {"address":addr, "account":"", "amount":Decimal("0.1"), "confirmations":10, "txids":[txid,]})
-        #With min confidence < 10
+        # With min confidence < 10
         check_array_result(self.nodes[1].listreceivedbyaddress(5),
                            {"address":addr},
                            {"address":addr, "account":"", "amount":Decimal("0.1"), "confirmations":10, "txids":[txid,]})
-        #With min confidence > 10, should not find Tx
+        # With min confidence > 10, should not find Tx
         check_array_result(self.nodes[1].listreceivedbyaddress(11),{"address":addr},{ },True)
 
-        #Empty Tx
+        # Empty Tx
         addr = self.nodes[1].getnewaddress()
         check_array_result(self.nodes[1].listreceivedbyaddress(0,True),
                            {"address":addr},
                            {"address":addr, "account":"", "amount":0, "confirmations":0, "txids":[]})
 
         '''
-            getreceivedbyaddress Test
+        getreceivedbyaddress Test
         '''
         # Send from node 0 to 1
         addr = self.nodes[1].getnewaddress()
         txid = self.nodes[0].sendtoaddress(addr, 0.1)
         self.sync_all()
 
-        #Check balance is 0 because of 0 confirmations
+        # Check balance is 0 because of 0 confirmations
         balance = self.nodes[1].getreceivedbyaddress(addr)
         if balance != Decimal("0.0"):
             raise AssertionError("Wrong balance returned by getreceivedbyaddress, %0.2f"%(balance))
 
-        #Check balance is 0.1
+        # Check balance is 0.1
         balance = self.nodes[1].getreceivedbyaddress(addr,0)
         if balance != Decimal("0.1"):
             raise AssertionError("Wrong balance returned by getreceivedbyaddress, %0.2f"%(balance))
 
-        #Bury Tx under 10 block so it will be returned by the default getreceivedbyaddress
+        # Bury Tx under 10 block so it will be returned by the default getreceivedbyaddress
         self.nodes[1].generate(10)
         self.sync_all()
         balance = self.nodes[1].getreceivedbyaddress(addr)
@@ -112,15 +111,15 @@ class ReceivedByTest(BitcoinTestFramework):
             raise AssertionError("Wrong balance returned by getreceivedbyaddress, %0.2f"%(balance))
 
         '''
-            listreceivedbyaccount + getreceivedbyaccount Test
+        listreceivedbyaccount + getreceivedbyaccount Test
         '''
-        #set pre-state
+        # set pre-state
         addrArr = self.nodes[1].getnewaddress()
         account = self.nodes[1].getaccount(addrArr)
         received_by_account_json = get_sub_array_from_array(self.nodes[1].listreceivedbyaccount(),{"account":account})
         if len(received_by_account_json) == 0:
             raise AssertionError("No accounts found in node")
-        balance_by_account = rec_by_accountArr = self.nodes[1].getreceivedbyaccount(account)
+        balance_by_account = self.nodes[1].getreceivedbyaccount(account)
 
         txid = self.nodes[0].sendtoaddress(addr, 0.1)
         self.sync_all()
@@ -147,7 +146,7 @@ class ReceivedByTest(BitcoinTestFramework):
         if balance != balance_by_account + Decimal("0.1"):
             raise AssertionError("Wrong balance returned by getreceivedbyaccount, %0.2f"%(balance))
 
-        #Create a new account named "mynewaccount" that has a 0 balance
+        # Create a new account named "mynewaccount" that has a 0 balance
         self.nodes[1].getaccountaddress("mynewaccount")
         received_by_account_json = get_sub_array_from_array(self.nodes[1].listreceivedbyaccount(0,True),{"account":"mynewaccount"})
         if len(received_by_account_json) == 0:
diff --git a/qa/rpc-tests/reindex.py b/qa/rpc-tests/reindex.py
index f2e3f248e..ae7563192 100755
--- a/qa/rpc-tests/reindex.py
+++ b/qa/rpc-tests/reindex.py
@@ -6,9 +6,11 @@
 #
 # Test -reindex with CheckBlockIndex
 #
+
 from test_framework.test_framework import BitcoinTestFramework
-from test_framework.util import *
-import os.path
+from test_framework.util import assert_equal, initialize_chain_clean, \
+    start_node, stop_node, wait_bitcoinds
+
 
 class ReindexTest(BitcoinTestFramework):
 
diff --git a/qa/rpc-tests/rest.py b/qa/rpc-tests/rest.py
index d315c66d3..b14ec765d 100755
--- a/qa/rpc-tests/rest.py
+++ b/qa/rpc-tests/rest.py
@@ -7,14 +7,15 @@
 # Test REST interface
 #
 
-
 from test_framework.test_framework import BitcoinTestFramework
-from test_framework.util import *
-from struct import *
+from test_framework.util import assert_equal, assert_greater_than, \
+    initialize_chain_clean, start_nodes, connect_nodes_bi
+
+import struct
 import binascii
 import json
 import StringIO
-import decimal
+from decimal import Decimal
 
 try:
     import http.client as httplib
@@ -28,11 +29,11 @@ except ImportError:
 def deser_uint256(f):
     r = 0
     for i in range(8):
-        t = unpack(b"<I", f.read(4))[0]
+        t = struct.unpack(b"<I", f.read(4))[0]
         r += t << (i * 32)
     return r
 
-#allows simple http get calls
+# allows simple http get calls
 def http_get_call(host, port, path, response_object = 0):
     conn = httplib.HTTPConnection(host, port)
     conn.request('GET', path)
@@ -42,7 +43,7 @@ def http_get_call(host, port, path, response_object = 0):
 
     return conn.getresponse().read()
 
-#allows simple http post calls with a request body
+# allows simple http post calls with a request body
 def http_post_call(host, port, path, requestdata = '', response_object = 0):
     conn = httplib.HTTPConnection(host, port)
     conn.request('POST', path, requestdata)
@@ -84,7 +85,7 @@ class RESTTest (BitcoinTestFramework):
         self.sync_all()
         bb_hash = self.nodes[0].getbestblockhash()
 
-        assert_equal(self.nodes[1].getbalance(), Decimal("0.1")) #balance now should be 0.1 on node 1
+        assert_equal(self.nodes[1].getbalance(), Decimal("0.1")) # balance now should be 0.1 on node 1
 
         # load the latest 0.1 tx over the REST API
         json_string = http_get_call(url.hostname, url.port, '/rest/tx/'+txid+self.FORMAT_SEPARATOR+"json")
@@ -119,13 +120,13 @@ class RESTTest (BitcoinTestFramework):
         json_string = http_get_call(url.hostname, url.port, '/rest/getutxos'+json_request+self.FORMAT_SEPARATOR+'json')
         json_obj = json.loads(json_string)
 
-        #check chainTip response
+        # check chainTip response
         assert_equal(json_obj['chaintipHash'], bb_hash)
 
-        #make sure there is no utox in the response because this oupoint has been spent
+        # make sure there is no utox in the response because this oupoint has been spent
         assert_equal(len(json_obj['utxos']), 0)
 
-        #check bitmap
+        # check bitmap
         assert_equal(json_obj['bitmap'], "0")
 
 
@@ -138,24 +139,24 @@ class RESTTest (BitcoinTestFramework):
         assert_equal(len(json_obj['utxos']), 1)
         assert_equal(json_obj['bitmap'], "10")
 
-        #test binary response
+        # test binary response
         bb_hash = self.nodes[0].getbestblockhash()
 
         binaryRequest = b'\x01\x02'
         binaryRequest += binascii.unhexlify(txid)
-        binaryRequest += pack("i", n);
+        binaryRequest += struct.pack("i", n);
         binaryRequest += binascii.unhexlify(vintx);
-        binaryRequest += pack("i", 0);
+        binaryRequest += struct.pack("i", 0);
 
         bin_response = http_post_call(url.hostname, url.port, '/rest/getutxos'+self.FORMAT_SEPARATOR+'bin', binaryRequest)
         output = StringIO.StringIO()
         output.write(bin_response)
         output.seek(0)
-        chainHeight = unpack("i", output.read(4))[0]
+        chainHeight = struct.unpack("i", output.read(4))[0]
         hashFromBinResponse = hex(deser_uint256(output))[2:].zfill(65).rstrip("L")
 
-        assert_equal(bb_hash, hashFromBinResponse) #check if getutxo's chaintip during calculation was fine
-        assert_equal(chainHeight, 102) #chain height must be 102
+        assert_equal(bb_hash, hashFromBinResponse) # check if getutxo's chaintip during calculation was fine
+        assert_equal(chainHeight, 102) # chain height must be 102
 
 
         ############################
@@ -176,41 +177,41 @@ class RESTTest (BitcoinTestFramework):
         json_request = '/'+txid+'-'+str(n)
         json_string = http_get_call(url.hostname, url.port, '/rest/getutxos'+json_request+self.FORMAT_SEPARATOR+'json')
         json_obj = json.loads(json_string)
-        assert_equal(len(json_obj['utxos']), 0) #there should be a outpoint because it has just added to the mempool
+        assert_equal(len(json_obj['utxos']), 0) # there should be a outpoint because it has just added to the mempool
 
         json_request = '/checkmempool/'+txid+'-'+str(n)
         json_string = http_get_call(url.hostname, url.port, '/rest/getutxos'+json_request+self.FORMAT_SEPARATOR+'json')
         json_obj = json.loads(json_string)
-        assert_equal(len(json_obj['utxos']), 1) #there should be a outpoint because it has just added to the mempool
+        assert_equal(len(json_obj['utxos']), 1) # there should be a outpoint because it has just added to the mempool
 
-        #do some invalid requests
+        # do some invalid requests
         json_request = '{"checkmempool'
         response = http_post_call(url.hostname, url.port, '/rest/getutxos'+self.FORMAT_SEPARATOR+'json', json_request, True)
-        assert_equal(response.status, 500) #must be a 500 because we send a invalid json request
+        assert_equal(response.status, 500) # must be a 500 because we send a invalid json request
 
         json_request = '{"checkmempool'
         response = http_post_call(url.hostname, url.port, '/rest/getutxos'+self.FORMAT_SEPARATOR+'bin', json_request, True)
-        assert_equal(response.status, 500) #must be a 500 because we send a invalid bin request
+        assert_equal(response.status, 500) # must be a 500 because we send a invalid bin request
 
         response = http_post_call(url.hostname, url.port, '/rest/getutxos/checkmempool'+self.FORMAT_SEPARATOR+'bin', '', True)
-        assert_equal(response.status, 500) #must be a 500 because we send a invalid bin request
+        assert_equal(response.status, 500) # must be a 500 because we send a invalid bin request
 
-        #test limits
+        # test limits
         json_request = '/checkmempool/'
         for x in range(0, 20):
             json_request += txid+'-'+str(n)+'/'
         json_request = json_request.rstrip("/")
         response = http_post_call(url.hostname, url.port, '/rest/getutxos'+json_request+self.FORMAT_SEPARATOR+'json', '', True)
-        assert_equal(response.status, 500) #must be a 500 because we exceeding the limits
+        assert_equal(response.status, 500) # must be a 500 because we exceeding the limits
 
         json_request = '/checkmempool/'
         for x in range(0, 15):
             json_request += txid+'-'+str(n)+'/'
         json_request = json_request.rstrip("/");
         response = http_post_call(url.hostname, url.port, '/rest/getutxos'+json_request+self.FORMAT_SEPARATOR+'json', '', True)
-        assert_equal(response.status, 200) #must be a 500 because we exceeding the limits
+        assert_equal(response.status, 200) # must be a 500 because we exceeding the limits
 
-        self.nodes[0].generate(1) #generate block to not affect upcoming tests
+        self.nodes[0].generate(1) # generate block to not affect upcoming tests
         self.sync_all()
 
         ################
@@ -263,11 +264,11 @@ class RESTTest (BitcoinTestFramework):
         response_header_json = http_get_call(url.hostname, url.port, '/rest/headers/1/'+bb_hash+self.FORMAT_SEPARATOR+"json", True)
         assert_equal(response_header_json.status, 200)
         response_header_json_str = response_header_json.read()
-        json_obj = json.loads(response_header_json_str, parse_float=decimal.Decimal)
-        assert_equal(len(json_obj), 1) #ensure that there is one header in the json response
-        assert_equal(json_obj[0]['hash'], bb_hash) #request/response hash should be the same
+        json_obj = json.loads(response_header_json_str, parse_float=Decimal)
+        assert_equal(len(json_obj), 1) # ensure that there is one header in the json response
+        assert_equal(json_obj[0]['hash'], bb_hash) # request/response hash should be the same
 
-        #compare with normal RPC block response
+        # compare with normal RPC block response
         rpc_block_json = self.nodes[0].getblock(bb_hash)
         assert_equal(json_obj[0]['hash'],               rpc_block_json['hash'])
         assert_equal(json_obj[0]['confirmations'],      rpc_block_json['confirmations'])
@@ -281,14 +282,14 @@ class RESTTest (BitcoinTestFramework):
         assert_equal(json_obj[0]['chainwork'],          rpc_block_json['chainwork'])
         assert_equal(json_obj[0]['previousblockhash'],  rpc_block_json['previousblockhash'])
 
-        #see if we can get 5 headers in one response
+        # see if we can get 5 headers in one response
         self.nodes[1].generate(5)
         self.sync_all()
         response_header_json = http_get_call(url.hostname, url.port, '/rest/headers/5/'+bb_hash+self.FORMAT_SEPARATOR+"json", True)
         assert_equal(response_header_json.status, 200)
         response_header_json_str = response_header_json.read()
         json_obj = json.loads(response_header_json_str)
-        assert_equal(len(json_obj), 5) #now we should have 5 header objects
+        assert_equal(len(json_obj), 5) # now we should have 5 header objects
 
         # do tx test
         tx_hash = block_json_obj['tx'][0]['txid'];
@@ -328,20 +329,20 @@ class RESTTest (BitcoinTestFramework):
         newblockhash = self.nodes[1].generate(1)
         self.sync_all()
 
-        #check if the 3 tx show up in the new block
+        # check if the 3 tx show up in the new block
         json_string = http_get_call(url.hostname, url.port, '/rest/block/'+newblockhash[0]+self.FORMAT_SEPARATOR+'json')
         json_obj = json.loads(json_string)
         for tx in json_obj['tx']:
-            if not 'coinbase' in tx['vin'][0]: #exclude coinbase
+            if not 'coinbase' in tx['vin'][0]: # exclude coinbase
                 assert_equal(tx['txid'] in txs, True)
 
-        #check the same but without tx details
+        # check the same but without tx details
         json_string = http_get_call(url.hostname, url.port, '/rest/block/notxdetails/'+newblockhash[0]+self.FORMAT_SEPARATOR+'json')
         json_obj = json.loads(json_string)
         for tx in txs:
             assert_equal(tx in json_obj['tx'], True)
 
-        #test rest bestblock
+        # test rest bestblock
         bb_hash = self.nodes[0].getbestblockhash()
 
         json_string = http_get_call(url.hostname, url.port, '/rest/chaininfo.json')
@@ -349,4 +350,4 @@ class RESTTest (BitcoinTestFramework):
         assert_equal(json_obj['bestblockhash'], bb_hash)
 
 if __name__ == '__main__':
-    RESTTest ().main ()
+    RESTTest().main()
diff --git a/qa/rpc-tests/rpcbind_test.py b/qa/rpc-tests/rpcbind_test.py
index 04110c283..72e14d655 100755
--- a/qa/rpc-tests/rpcbind_test.py
+++ b/qa/rpc-tests/rpcbind_test.py
@@ -5,19 +5,20 @@
 
 # Test for -rpcbind, as well as -rpcallowip and -rpcconnect
 
-# Add python-bitcoinrpc to module search path:
+# Dependency: python-bitcoinrpc
+
+from test_framework.util import assert_equal, check_json_precision, \
+    initialize_chain, start_nodes, stop_nodes, wait_bitcoinds, \
+    bitcoind_processes, rpc_port
+from test_framework.authproxy import AuthServiceProxy
+from test_framework.netutil import addr_to_hex, get_bind_addrs, all_interfaces
+
 import os
 import sys
-
-import json
 import shutil
-import subprocess
 import tempfile
 import traceback
 
-from test_framework.util import *
-from test_framework.netutil import *
-
 def run_bind_test(tmpdir, allow_ips, connect_to, addresses, expected):
     '''
     Start a node with requested rpcallowip and rpcbind parameters,
@@ -119,7 +120,6 @@ def main():
     check_json_precision()
 
     success = False
-    nodes = []
     try:
         print("Initializing test directory "+options.tmpdir)
         if not os.path.isdir(options.tmpdir):
diff --git a/qa/rpc-tests/script_test.py b/qa/rpc-tests/script_test.py
index 85927d02c..c3ad541e5 100755
--- a/qa/rpc-tests/script_test.py
+++ b/qa/rpc-tests/script_test.py
@@ -20,13 +20,12 @@ NOTE: This test is very slow and may take more than 40 minutes to run.
 '''
 
 from test_framework.test_framework import ComparisonTestFramework
-from test_framework.util import *
 from test_framework.comptool import TestInstance, TestManager
-from test_framework.mininode import *
-from test_framework.blocktools import *
-from test_framework.script import *
-import logging
-import copy
+from test_framework.mininode import NetworkThread
+from test_framework.blocktools import create_block, create_coinbase, create_transaction
+from test_framework.script import CScript, CScriptOp, CScriptNum, OPCODES_BY_NAME
+
+import os
 import json
 
 script_valid_file   = "../../src/test/data/script_valid.json"
diff --git a/qa/rpc-tests/signrawtransactions.py b/qa/rpc-tests/signrawtransactions.py
index 286fc8683..95d242854 100755
--- a/qa/rpc-tests/signrawtransactions.py
+++ b/qa/rpc-tests/signrawtransactions.py
@@ -4,7 +4,8 @@
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 from test_framework.test_framework import BitcoinTestFramework
-from test_framework.util import *
+from test_framework.util import assert_equal, initialize_chain_clean, \
+    start_nodes
 
 
 class SignRawTransactionsTest(BitcoinTestFramework):
diff --git a/qa/rpc-tests/smartfees.py b/qa/rpc-tests/smartfees.py
index c15c5fda0..e111a406b 100755
--- a/qa/rpc-tests/smartfees.py
+++ b/qa/rpc-tests/smartfees.py
@@ -8,7 +8,11 @@
 #
 
 from test_framework.test_framework import BitcoinTestFramework
-from test_framework.util import *
+from test_framework.util import start_node, connect_nodes, \
+    sync_blocks, sync_mempools
+
+import random
+from decimal import Decimal, ROUND_DOWN
 
 # Construct 2 trivial P2SH's and the ScriptSigs that spend them
 # So we can create many many transactions without needing to spend
diff --git a/qa/rpc-tests/test_framework/blockstore.py b/qa/rpc-tests/test_framework/blockstore.py
index c57b6df81..fc157f718 100644
--- a/qa/rpc-tests/test_framework/blockstore.py
+++ b/qa/rpc-tests/test_framework/blockstore.py
@@ -3,14 +3,17 @@
 #             and for constructing a getheaders message
 #
 
-from mininode import *
+from mininode import CBlock, CBlockHeader, CBlockLocator, CTransaction, msg_block, msg_headers, msg_tx
+
+import sys
+import cStringIO
 import dbm
 
 class BlockStore(object):
     def __init__(self, datadir):
         self.blockDB = dbm.open(datadir + "/blocks", 'c')
         self.currentBlock = 0L
-    
+
     def close(self):
         self.blockDB.close()
 
diff --git a/qa/rpc-tests/test_framework/blocktools.py b/qa/rpc-tests/test_framework/blocktools.py
index f397fe7cd..0f8147253 100644
--- a/qa/rpc-tests/test_framework/blocktools.py
+++ b/qa/rpc-tests/test_framework/blocktools.py
@@ -4,8 +4,7 @@
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 #
 
-from mininode import *
-from script import CScript, CScriptOp
+from mininode import CBlock, CTransaction, CTxIn, CTxOut, COutPoint, ser_string
 
 # Create a block (with regtest difficulty)
 def create_block(hashprev, coinbase, nTime=None):
diff --git a/qa/rpc-tests/test_framework/comptool.py b/qa/rpc-tests/test_framework/comptool.py
index b945f1bf2..7f9a97d68 100755
--- a/qa/rpc-tests/test_framework/comptool.py
+++ b/qa/rpc-tests/test_framework/comptool.py
@@ -4,10 +4,13 @@
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 #
 
-from mininode import *
+from mininode import CBlock, CTransaction, CInv, NodeConn, NodeConnCB, \
+    msg_inv, msg_getheaders, msg_ping, msg_mempool, mininode_lock, MAX_INV_SZ
 from blockstore import BlockStore, TxStore
 from util import p2p_port
 
+import time
+
 '''
 This is a tool for comparing two or more bitcoinds to each other
 using a script provided.
@@ -25,8 +28,6 @@ generator that returns TestInstance objects.  See below for definition.
 # on_getheaders: provide headers via BlockStore
 # on_getdata: provide blocks via BlockStore
 
-global mininode_lock
-
 def wait_until(predicate, attempts=float('inf'), timeout=float('inf')):
     attempt = 0
     elapsed = 0
diff --git a/qa/rpc-tests/test_framework/script.py b/qa/rpc-tests/test_framework/script.py
index e37ab5d45..ab7f4ec74 100644
--- a/qa/rpc-tests/test_framework/script.py
+++ b/qa/rpc-tests/test_framework/script.py
@@ -24,10 +24,10 @@ if sys.version > '3':
     bchr = lambda x: bytes([x])
     bord = lambda x: x
 
-import copy
 import struct
+import binascii
 
-import test_framework.bignum
+from test_framework import bignum
 
 MAX_SCRIPT_SIZE = 10000
 MAX_SCRIPT_ELEMENT_SIZE = 520
diff --git a/qa/rpc-tests/test_framework/test_framework.py b/qa/rpc-tests/test_framework/test_framework.py
index f44a10a40..56151bb3e 100755
--- a/qa/rpc-tests/test_framework/test_framework.py
+++ b/qa/rpc-tests/test_framework/test_framework.py
@@ -13,8 +13,11 @@ import shutil
 import tempfile
 import traceback
 
-from authproxy import AuthServiceProxy, JSONRPCException
-from util import *
+from authproxy import JSONRPCException
+from util import assert_equal, check_json_precision, \
+    initialize_chain, initialize_chain_clean, \
+    start_nodes, connect_nodes_bi, stop_nodes, \
+    sync_blocks, sync_mempools, wait_bitcoinds
 
 
 class BitcoinTestFramework(object):
diff --git a/qa/rpc-tests/test_framework/util.py b/qa/rpc-tests/test_framework/util.py
index f5ef9dec6..8ac09f472 100644
--- a/qa/rpc-tests/test_framework/util.py
+++ b/qa/rpc-tests/test_framework/util.py
@@ -21,8 +21,7 @@ import subprocess
 import time
 import re
 
-from authproxy import AuthServiceProxy, JSONRPCException
-from util import *
+from authproxy import AuthServiceProxy
 
 def p2p_port(n):
     return 11000 + n + os.getpid()%999
@@ -153,7 +152,7 @@ def initialize_chain_clean(test_dir, num_nodes):
     Useful if a test case wants complete control over initialization.
     """
     for i in range(num_nodes):
-        datadir=initialize_datadir(test_dir, i)
+        initialize_datadir(test_dir, i)
 
 
 def _rpchost_to_args(rpchost):
diff --git a/qa/rpc-tests/txn_doublespend.py b/qa/rpc-tests/txn_doublespend.py
index 32699ad9d..bbe383d16 100755
--- a/qa/rpc-tests/txn_doublespend.py
+++ b/qa/rpc-tests/txn_doublespend.py
@@ -8,10 +8,9 @@
 #
 
 from test_framework.test_framework import BitcoinTestFramework
-from test_framework.util import *
-from decimal import Decimal
-import os
-import shutil
+from test_framework.util import assert_equal, connect_nodes, \
+    sync_blocks, gather_inputs
+
 
 class TxnMallTest(BitcoinTestFramework):
 
@@ -77,7 +76,7 @@ class TxnMallTest(BitcoinTestFramework):
             assert_equal(tx2["confirmations"], 0)
 
         # Now give doublespend to miner:
-        mutated_txid = self.nodes[2].sendrawtransaction(doublespend["hex"])
+        self.nodes[2].sendrawtransaction(doublespend["hex"])
         # ... mine a block...
         self.nodes[2].generate(1)
 
diff --git a/qa/rpc-tests/wallet.py b/qa/rpc-tests/wallet.py
index 555a3e902..9b91c803d 100755
--- a/qa/rpc-tests/wallet.py
+++ b/qa/rpc-tests/wallet.py
@@ -5,8 +5,13 @@
 
 
 from test_framework.test_framework import BitcoinTestFramework
-from test_framework.util import *
-from time import *
+from test_framework.authproxy import JSONRPCException
+from test_framework.util import assert_equal, assert_greater_than, \
+    initialize_chain_clean, start_nodes, start_node, connect_nodes_bi, \
+    stop_nodes, sync_blocks, sync_mempools, wait_bitcoinds
+
+import time
+from decimal import Decimal
 
 class WalletTest (BitcoinTestFramework):
 
@@ -112,7 +117,7 @@ class WalletTest (BitcoinTestFramework):
         # Send 10 BTC normal
         address = self.nodes[0].getnewaddress("")
         self.nodes[2].settxfee(Decimal('0.001'))
-        txid = self.nodes[2].sendtoaddress(address, 10, "", "", False)
+        self.nodes[2].sendtoaddress(address, 10, "", "", False)
         self.sync_all()
         self.nodes[2].generate(1)
         self.sync_all()
@@ -122,7 +127,7 @@ class WalletTest (BitcoinTestFramework):
         assert_equal(self.nodes[0].getbalance("*"), Decimal('10.00000000'))
 
         # Send 10 BTC with subtract fee from amount
-        txid = self.nodes[2].sendtoaddress(address, 10, "", "", True)
+        self.nodes[2].sendtoaddress(address, 10, "", "", True)
         self.sync_all()
         self.nodes[2].generate(1)
         self.sync_all()
@@ -132,7 +137,7 @@ class WalletTest (BitcoinTestFramework):
         assert_equal(self.nodes[0].getbalance("*"), Decimal('19.99900000'))
 
         # Sendmany 10 BTC
-        txid = self.nodes[2].sendmany("", {address: 10}, 0, "", [])
+        self.nodes[2].sendmany("", {address: 10}, 0, "", [])
         self.sync_all()
         self.nodes[2].generate(1)
         self.sync_all()
@@ -142,7 +147,7 @@ class WalletTest (BitcoinTestFramework):
         assert_equal(self.nodes[0].getbalance("*"), Decimal('29.99900000'))
 
         # Sendmany 10 BTC with subtract fee from amount
-        txid = self.nodes[2].sendmany("", {address: 10}, 0, "", [address])
+        self.nodes[2].sendmany("", {address: 10}, 0, "", [address])
         self.sync_all()
         self.nodes[2].generate(1)
         self.sync_all()
@@ -183,7 +188,7 @@ class WalletTest (BitcoinTestFramework):
         signedRawTx = self.nodes[1].signrawtransaction(rawTx)
         decRawTx = self.nodes[1].decoderawtransaction(signedRawTx['hex'])
         zeroValueTxid= decRawTx['txid']
-        sendResp = self.nodes[1].sendrawtransaction(signedRawTx['hex'])
+        self.nodes[1].sendrawtransaction(signedRawTx['hex'])
 
         self.sync_all()
         self.nodes[1].generate(1) #mine a block
@@ -250,7 +255,7 @@ class WalletTest (BitcoinTestFramework):
         self.sync_all()
 
         mybalance = self.nodes[2].z_getbalance(mytaddr)
-        assert_equal(self.nodes[2].z_getbalance(mytaddr), Decimal('10.0'));
+        assert_equal(mybalance, Decimal('10.0'));
 
         mytxdetails = self.nodes[2].gettransaction(mytxid)
         myvjoinsplits = mytxdetails["vjoinsplit"]
@@ -318,7 +323,7 @@ class WalletTest (BitcoinTestFramework):
         for x in xrange(1, timeout):
             results = self.nodes[2].z_getoperationresult(opids)
             if len(results)==0:
-                sleep(1)
+                time.sleep(1)
             else:
                 status = results[0]["status"]
                 mytxid = results[0]["result"]["txid"]
@@ -375,7 +380,7 @@ class WalletTest (BitcoinTestFramework):
         for x in xrange(1, timeout):
             results = self.nodes[2].z_getoperationresult(opids)
             if len(results)==0:
-                sleep(1)
+                time.sleep(1)
             else:
                 status = results[0]["status"]
                 break
diff --git a/qa/rpc-tests/wallet_1941.py b/qa/rpc-tests/wallet_1941.py
index 5f2fe3f72..d6f024020 100755
--- a/qa/rpc-tests/wallet_1941.py
+++ b/qa/rpc-tests/wallet_1941.py
@@ -6,10 +6,12 @@
 # This is a regression test for #1941.
 
 from test_framework.test_framework import BitcoinTestFramework
-from test_framework.util import *
-from time import *
+from test_framework.util import assert_equal, initialize_chain_clean, \
+    initialize_datadir, start_nodes, start_node, connect_nodes_bi, \
+    bitcoind_processes
 
-import sys
+import time
+from decimal import Decimal
 
 starttime = 1388534400
 
@@ -49,7 +51,7 @@ class Wallet1941RegressionTest (BitcoinTestFramework):
         for x in xrange(1, timeout):
             results = self.nodes[0].z_getoperationresult(opids)
             if len(results)==0:
-                sleep(1)
+                time.sleep(1)
             else:
                 status = results[0]["status"]
                 if status == "failed":
diff --git a/qa/rpc-tests/wallet_nullifiers.py b/qa/rpc-tests/wallet_nullifiers.py
index 93f5a499d..b7e94b6a6 100755
--- a/qa/rpc-tests/wallet_nullifiers.py
+++ b/qa/rpc-tests/wallet_nullifiers.py
@@ -5,8 +5,11 @@
 
 
 from test_framework.test_framework import BitcoinTestFramework
-from test_framework.util import *
-from time import *
+from test_framework.util import assert_equal, start_node, \
+    start_nodes, connect_nodes_bi, bitcoind_processes
+
+import time
+from decimal import Decimal
 
 class WalletNullifiersTest (BitcoinTestFramework):
 
@@ -32,7 +35,7 @@ class WalletNullifiersTest (BitcoinTestFramework):
         for x in xrange(1, timeout):
             results = self.nodes[0].z_getoperationresult(opids)
             if len(results)==0:
-                sleep(1)
+                time.sleep(1)
             else:
                 status = results[0]["status"]
                 assert_equal("success", status)
@@ -73,7 +76,7 @@ class WalletNullifiersTest (BitcoinTestFramework):
         for x in xrange(1, timeout):
             results = self.nodes[0].z_getoperationresult(opids)
             if len(results)==0:
-                sleep(1)
+                time.sleep(1)
             else:
                 status = results[0]["status"]
                 assert_equal("success", status)
@@ -105,7 +108,7 @@ class WalletNullifiersTest (BitcoinTestFramework):
         for x in xrange(1, timeout):
             results = self.nodes[2].z_getoperationresult(opids)
             if len(results)==0:
-                sleep(1)
+                time.sleep(1)
             else:
                 status = results[0]["status"]
                 assert_equal("success", status)
@@ -146,11 +149,12 @@ class WalletNullifiersTest (BitcoinTestFramework):
         for x in xrange(1, timeout):
             results = self.nodes[1].z_getoperationresult(opids)
             if len(results)==0:
-                sleep(1)
+                time.sleep(1)
             else:
                 status = results[0]["status"]
                 assert_equal("success", status)
                 mytxid = results[0]["result"]["txid"]
+                [mytxid] # hush pyflakes
                 break
 
         self.sync_all()
diff --git a/qa/rpc-tests/wallet_protectcoinbase.py b/qa/rpc-tests/wallet_protectcoinbase.py
index 1ed0d5b1f..6dd023c55 100755
--- a/qa/rpc-tests/wallet_protectcoinbase.py
+++ b/qa/rpc-tests/wallet_protectcoinbase.py
@@ -5,8 +5,13 @@
 
 
 from test_framework.test_framework import BitcoinTestFramework
-from test_framework.util import *
-from time import *
+from test_framework.authproxy import JSONRPCException
+from test_framework.util import assert_equal, initialize_chain_clean, \
+    start_nodes, connect_nodes_bi
+
+import sys
+import time
+from decimal import Decimal
 
 class WalletProtectCoinbaseTest (BitcoinTestFramework):
 
@@ -35,7 +40,7 @@ class WalletProtectCoinbaseTest (BitcoinTestFramework):
         for x in xrange(1, timeout):
             results = self.nodes[0].z_getoperationresult(opids)
             if len(results)==0:
-                sleep(1)
+                time.sleep(1)
             else:
                 status = results[0]["status"]
                 if status == "failed":
@@ -94,7 +99,7 @@ class WalletProtectCoinbaseTest (BitcoinTestFramework):
         for x in xrange(1, timeout):
             results = self.nodes[0].z_getoperationresult(opids)
             if len(results)==0:
-                sleep(1)
+                time.sleep(1)
             else:
                 status = results[0]["status"]
                 errorString = results[0]["error"]["message"]
diff --git a/qa/rpc-tests/wallet_treestate.py b/qa/rpc-tests/wallet_treestate.py
index ae55368f0..c7fe9bf25 100755
--- a/qa/rpc-tests/wallet_treestate.py
+++ b/qa/rpc-tests/wallet_treestate.py
@@ -5,10 +5,11 @@
 
 
 from test_framework.test_framework import BitcoinTestFramework
-from test_framework.util import *
-from time import *
+from test_framework.util import assert_equal, initialize_chain_clean, \
+    start_nodes, connect_nodes_bi
 
-import sys
+import time
+from decimal import Decimal
 
 class WalletTreeStateTest (BitcoinTestFramework):
 
@@ -35,7 +36,7 @@ class WalletTreeStateTest (BitcoinTestFramework):
         for x in xrange(1, timeout):
             results = self.nodes[0].z_getoperationresult(opids)
             if len(results)==0:
-                sleep(1)
+                time.sleep(1)
             else:
                 status = results[0]["status"]
                 if status == "failed":
@@ -106,7 +107,7 @@ class WalletTreeStateTest (BitcoinTestFramework):
             status = results[0]["status"]
             if status == "executing":
                 break
-            sleep(1)
+            time.sleep(1)
 
         # Now mine Tx 1 which will change global treestate before Tx 2's second joinsplit begins processing
         self.sync_all()
diff --git a/qa/rpc-tests/walletbackup.py b/qa/rpc-tests/walletbackup.py
index 5f3eb6fcc..37c1db9a5 100755
--- a/qa/rpc-tests/walletbackup.py
+++ b/qa/rpc-tests/walletbackup.py
@@ -34,9 +34,16 @@ and confirm again balances are correct.
 """
 
 from test_framework.test_framework import BitcoinTestFramework
-from test_framework.util import *
+from test_framework.util import assert_equal, initialize_chain_clean, \
+    start_nodes, start_node, connect_nodes, stop_node, \
+    sync_blocks, sync_mempools
+
+import os
+import shutil
 from random import randint
+from decimal import Decimal
 import logging
+
 logging.basicConfig(format='%(levelname)s:%(message)s', level=logging.INFO)
 
 class WalletBackupTest(BitcoinTestFramework):
diff --git a/qa/rpc-tests/zapwallettxes.py b/qa/rpc-tests/zapwallettxes.py
index b15138818..5da4ba125 100755
--- a/qa/rpc-tests/zapwallettxes.py
+++ b/qa/rpc-tests/zapwallettxes.py
@@ -4,7 +4,9 @@
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 from test_framework.test_framework import BitcoinTestFramework
-from test_framework.util import *
+from test_framework.authproxy import JSONRPCException
+from test_framework.util import assert_equal, initialize_chain_clean, \
+    start_nodes, start_node, connect_nodes_bi, bitcoind_processes
 
 
 class ZapWalletTXesTest (BitcoinTestFramework):
@@ -27,56 +29,56 @@ class ZapWalletTXesTest (BitcoinTestFramework):
         self.sync_all()
         self.nodes[1].generate(101)
         self.sync_all()
-        
+
         assert_equal(self.nodes[0].getbalance(), 40)
-        
+
         txid0 = self.nodes[0].sendtoaddress(self.nodes[2].getnewaddress(), 11)
         txid1 = self.nodes[0].sendtoaddress(self.nodes[2].getnewaddress(), 10)
         self.sync_all()
         self.nodes[0].generate(1)
         self.sync_all()
-        
+
         txid2 = self.nodes[0].sendtoaddress(self.nodes[2].getnewaddress(), 11)
         txid3 = self.nodes[0].sendtoaddress(self.nodes[2].getnewaddress(), 5)
-        
+
         tx0 = self.nodes[0].gettransaction(txid0)
-        assert_equal(tx0['txid'], txid0) #tx0 must be available (confirmed)
-        
+        assert_equal(tx0['txid'], txid0) # tx0 must be available (confirmed)
+
         tx1 = self.nodes[0].gettransaction(txid1)
-        assert_equal(tx1['txid'], txid1) #tx1 must be available (confirmed)
-        
+        assert_equal(tx1['txid'], txid1) # tx1 must be available (confirmed)
+
         tx2 = self.nodes[0].gettransaction(txid2)
-        assert_equal(tx2['txid'], txid2) #tx2 must be available (unconfirmed)
-        
+        assert_equal(tx2['txid'], txid2) # tx2 must be available (unconfirmed)
+
         tx3 = self.nodes[0].gettransaction(txid3)
-        assert_equal(tx3['txid'], txid3) #tx3 must be available (unconfirmed)
-        
-        #restart bitcoind
+        assert_equal(tx3['txid'], txid3) # tx3 must be available (unconfirmed)
+
+        # restart zcashd
         self.nodes[0].stop()
         bitcoind_processes[0].wait()
         self.nodes[0] = start_node(0,self.options.tmpdir)
-        
+
         tx3 = self.nodes[0].gettransaction(txid3)
-        assert_equal(tx3['txid'], txid3) #tx must be available (unconfirmed)
-        
+        assert_equal(tx3['txid'], txid3) # tx must be available (unconfirmed)
+
         self.nodes[0].stop()
         bitcoind_processes[0].wait()
-        
-        #restart bitcoind with zapwallettxes
+
+        # restart zcashd with zapwallettxes
         self.nodes[0] = start_node(0,self.options.tmpdir, ["-zapwallettxes=1"])
-        
+
         aException = False
         try:
             tx3 = self.nodes[0].gettransaction(txid3)
         except JSONRPCException,e:
             print e
             aException = True
-        
-        assert_equal(aException, True) #there must be a expection because the unconfirmed wallettx0 must be gone by now
+
+        assert_equal(aException, True) # there must be a expection because the unconfirmed wallettx0 must be gone by now
 
         tx0 = self.nodes[0].gettransaction(txid0)
-        assert_equal(tx0['txid'], txid0) #tx0 (confirmed) must still be available because it was confirmed
+        assert_equal(tx0['txid'], txid0) # tx0 (confirmed) must still be available because it was confirmed
 
 
 if __name__ == '__main__':
-    ZapWalletTXesTest ().main ()
+    ZapWalletTXesTest().main()
diff --git a/qa/rpc-tests/zcjoinsplit.py b/qa/rpc-tests/zcjoinsplit.py
index 2b439e831..7e5aba6e3 100755
--- a/qa/rpc-tests/zcjoinsplit.py
+++ b/qa/rpc-tests/zcjoinsplit.py
@@ -5,11 +5,9 @@
 #
 
 from test_framework.test_framework import BitcoinTestFramework
-from test_framework.util import *
-from decimal import Decimal
-import os
-import shutil
-import sys
+from test_framework.util import assert_equal, start_node, \
+    gather_inputs
+
 
 class JoinSplitTest(BitcoinTestFramework):
     def setup_network(self):
diff --git a/qa/rpc-tests/zcjoinsplitdoublespend.py b/qa/rpc-tests/zcjoinsplitdoublespend.py
index cb89a9182..b8411c49d 100755
--- a/qa/rpc-tests/zcjoinsplitdoublespend.py
+++ b/qa/rpc-tests/zcjoinsplitdoublespend.py
@@ -5,11 +5,10 @@
 #
 
 from test_framework.test_framework import BitcoinTestFramework
-from test_framework.util import *
-from decimal import Decimal
-import os
-import shutil
-import sys
+from test_framework.authproxy import JSONRPCException
+from test_framework.util import assert_equal, connect_nodes, \
+    gather_inputs, sync_blocks
+
 import time
 
 class JoinSplitTest(BitcoinTestFramework):
diff --git a/qa/rpc-tests/zmq_test.py b/qa/rpc-tests/zmq_test.py
index 97850bea3..d70e73114 100755
--- a/qa/rpc-tests/zmq_test.py
+++ b/qa/rpc-tests/zmq_test.py
@@ -8,21 +8,12 @@
 #
 
 from test_framework.test_framework import BitcoinTestFramework
-from test_framework.util import *
+from test_framework.util import assert_equal, bytes_to_hex_str, start_nodes
+
 import zmq
-import binascii
 import struct
 
-try:
-    import http.client as httplib
-except ImportError:
-    import httplib
-try:
-    import urllib.parse as urlparse
-except ImportError:
-    import urlparse
-
-class ZMQTest (BitcoinTestFramework):
+class ZMQTest(BitcoinTestFramework):
 
     port = 28332
 
@@ -51,8 +42,9 @@ class ZMQTest (BitcoinTestFramework):
         assert_equal(topic, b"hashtx")
         body = msg[1]
         nseq = msg[2]
+        [nseq] # hush pyflakes
         msgSequence = struct.unpack('<I', msg[-1])[-1]
-        assert_equal(msgSequence, 0) #must be sequence 0 on hashtx
+        assert_equal(msgSequence, 0) # must be sequence 0 on hashtx
 
         msg = self.zmqSubSocket.recv_multipart()
         topic = msg[0]