diff --git a/test/functional/assumevalid.py b/test/functional/assumevalid.py
index bdf9a3602b..08f2bd6c05 100755
--- a/test/functional/assumevalid.py
+++ b/test/functional/assumevalid.py
@@ -1,215 +1,204 @@
 #!/usr/bin/env python3
 # Copyright (c) 2014-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.
 """Test logic for skipping signature validation on old blocks.
 
 Test logic for skipping signature validation on blocks which we've assumed
 valid (https://github.com/bitcoin/bitcoin/pull/9484)
 
 We build a chain that includes and invalid signature for one of the
 transactions:
 
     0:        genesis block
     1:        block 1 with coinbase transaction output.
     2-101:    bury that block with 100 blocks so the coinbase transaction
               output can be spent
     102:      a block containing a transaction spending the coinbase
               transaction output. The transaction has an invalid signature.
     103-2202: bury the bad block with just over two weeks' worth of blocks
               (2100 blocks)
 
 Start three nodes:
 
     - node0 has no -assumevalid parameter. Try to sync to block 2202. It will
       reject block 102 and only sync as far as block 101
     - node1 has -assumevalid set to the hash of block 102. Try to sync to
       block 2202. node1 will sync all the way to block 2202.
     - node2 has -assumevalid set to the hash of block 102. Try to sync to
       block 200. node2 will reject block 102 since it's assumed valid, but it
       isn't buried by at least two weeks' work.
 """
 import time
 
 from test_framework.blocktools import (create_block, create_coinbase)
 from test_framework.key import CECKey
 from test_framework.mininode import (CBlockHeader,
                                      COutPoint,
                                      CTransaction,
                                      CTxIn,
                                      CTxOut,
                                      NetworkThread,
-                                     NodeConn,
                                      NodeConnCB,
                                      msg_block,
                                      msg_headers)
 from test_framework.script import (CScript, OP_TRUE)
 from test_framework.test_framework import BitcoinTestFramework
-from test_framework.util import (p2p_port, assert_equal)
+from test_framework.util import assert_equal
 
 
 class BaseNode(NodeConnCB):
     def send_header_for_blocks(self, new_blocks):
         headers_message = msg_headers()
         headers_message.headers = [CBlockHeader(b) for b in new_blocks]
         self.send_message(headers_message)
 
 
 class AssumeValidTest(BitcoinTestFramework):
     def set_test_params(self):
         self.setup_clean_chain = True
         self.num_nodes = 3
 
     def setup_network(self):
         self.add_nodes(3)
         # Start node0. We don't start the other nodes yet since
         # we need to pre-mine a block with an invalid transaction
         # signature so we can pass in the block hash as assumevalid.
         self.start_node(0)
 
-    def send_blocks_until_disconnected(self, node):
+    def send_blocks_until_disconnected(self, p2p_conn):
         """Keep sending blocks to the node until we're disconnected."""
         for i in range(len(self.blocks)):
-            if not node.connection:
+            if not p2p_conn.connection:
                 break
             try:
-                node.send_message(msg_block(self.blocks[i]))
+                p2p_conn.send_message(msg_block(self.blocks[i]))
             except IOError as e:
                 assert str(e) == 'Not connected, no pushbuf'
                 break
 
     def assert_blockchain_height(self, node, height):
         """Wait until the blockchain is no longer advancing and verify it's reached the expected height."""
         last_height = node.getblock(node.getbestblockhash())['height']
         timeout = 10
         while True:
             time.sleep(0.25)
             current_height = node.getblock(node.getbestblockhash())['height']
             if current_height != last_height:
                 last_height = current_height
                 if timeout < 0:
                     assert False, "blockchain too short after timeout: %d" % current_height
                 timeout - 0.25
                 continue
             elif current_height > height:
                 assert False, "blockchain too long: %d" % current_height
             elif current_height == height:
                 break
 
     def run_test(self):
 
         # Connect to node0
-        node0 = BaseNode()
-        connections = []
-        connections.append(
-            NodeConn('127.0.0.1', p2p_port(0), self.nodes[0], node0))
-        node0.add_connection(connections[0])
+        p2p0 = self.nodes[0].add_p2p_connection(BaseNode())
 
         NetworkThread().start()  # Start up network handling in another thread
-        node0.wait_for_verack()
+        self.nodes[0].p2p.wait_for_verack()
 
         # Build the blockchain
         self.tip = int(self.nodes[0].getbestblockhash(), 16)
         self.block_time = self.nodes[0].getblock(
             self.nodes[0].getbestblockhash())['time'] + 1
 
         self.blocks = []
 
         # Get a pubkey for the coinbase TXO
         coinbase_key = CECKey()
         coinbase_key.set_secretbytes(b"horsebattery")
         coinbase_pubkey = coinbase_key.get_pubkey()
 
         # Create the first block with a coinbase output to our key
         height = 1
         block = create_block(self.tip, create_coinbase(
             height, coinbase_pubkey), self.block_time)
         self.blocks.append(block)
         self.block_time += 1
         block.solve()
         # Save the coinbase for later
         self.block1 = block
         self.tip = block.sha256
         height += 1
 
         # Bury the block 100 deep so the coinbase output is spendable
         for i in range(100):
             block = create_block(
                 self.tip, create_coinbase(height), self.block_time)
             block.solve()
             self.blocks.append(block)
             self.tip = block.sha256
             self.block_time += 1
             height += 1
 
         # Create a transaction spending the coinbase output with an invalid (null) signature
         tx = CTransaction()
         tx.vin.append(
             CTxIn(COutPoint(self.block1.vtx[0].sha256, 0), scriptSig=b""))
         tx.vout.append(CTxOut(49 * 100000000, CScript([OP_TRUE])))
         tx.calc_sha256()
 
         block102 = create_block(
             self.tip, create_coinbase(height), self.block_time)
         self.block_time += 1
         block102.vtx.extend([tx])
         block102.hashMerkleRoot = block102.calc_merkle_root()
         block102.rehash()
         block102.solve()
         self.blocks.append(block102)
         self.tip = block102.sha256
         self.block_time += 1
         height += 1
 
         # Bury the assumed valid block 2100 deep
         for i in range(2100):
             block = create_block(
                 self.tip, create_coinbase(height), self.block_time)
             block.nVersion = 4
             block.solve()
             self.blocks.append(block)
             self.tip = block.sha256
             self.block_time += 1
             height += 1
 
         # Start node1 and node2 with assumevalid so they accept a block with a bad signature.
         self.start_node(1, extra_args=["-assumevalid=" + hex(block102.sha256)])
-        node1 = BaseNode()  # connects to node1
-        connections.append(
-            NodeConn('127.0.0.1', p2p_port(1), self.nodes[1], node1))
-        node1.add_connection(connections[1])
-        node1.wait_for_verack()
+        p2p1 = self.nodes[1].add_p2p_connection(BaseNode())
+        p2p1.wait_for_verack()
 
         self.start_node(2, extra_args=["-assumevalid=" + hex(block102.sha256)])
-        node2 = BaseNode()  # connects to node2
-        connections.append(
-            NodeConn('127.0.0.1', p2p_port(2), self.nodes[2], node2))
-        node2.add_connection(connections[2])
-        node2.wait_for_verack()
+        p2p2 = self.nodes[2].add_p2p_connection(BaseNode())
+        p2p2.wait_for_verack()
 
         # send header lists to all three nodes
-        node0.send_header_for_blocks(self.blocks[0:2000])
-        node0.send_header_for_blocks(self.blocks[2000:])
-        node1.send_header_for_blocks(self.blocks[0:2000])
-        node1.send_header_for_blocks(self.blocks[2000:])
-        node2.send_header_for_blocks(self.blocks[0:200])
+        p2p0.send_header_for_blocks(self.blocks[0:2000])
+        p2p0.send_header_for_blocks(self.blocks[2000:])
+        p2p1.send_header_for_blocks(self.blocks[0:2000])
+        p2p1.send_header_for_blocks(self.blocks[2000:])
+        p2p2.send_header_for_blocks(self.blocks[0:200])
 
         # Send blocks to node0. Block 102 will be rejected.
-        self.send_blocks_until_disconnected(node0)
+        self.send_blocks_until_disconnected(p2p0)
         self.assert_blockchain_height(self.nodes[0], 101)
 
         # Send all blocks to node1. All blocks will be accepted.
         for i in range(2202):
-            node1.send_message(msg_block(self.blocks[i]))
+            p2p1.send_message(msg_block(self.blocks[i]))
         # Syncing 2200 blocks can take a while on slow systems. Give it plenty of time to sync.
-        node1.sync_with_ping(120)
+        p2p1.sync_with_ping(120)
         assert_equal(self.nodes[1].getblock(
             self.nodes[1].getbestblockhash())['height'], 2202)
 
         # Send blocks to node2. Block 102 will be rejected.
-        self.send_blocks_until_disconnected(node2)
+        self.send_blocks_until_disconnected(p2p2)
         self.assert_blockchain_height(self.nodes[2], 101)
 
 
 if __name__ == '__main__':
     AssumeValidTest().main()
diff --git a/test/functional/bip65-cltv-p2p.py b/test/functional/bip65-cltv-p2p.py
index 908dac7f45..cd8d685670 100755
--- a/test/functional/bip65-cltv-p2p.py
+++ b/test/functional/bip65-cltv-p2p.py
@@ -1,248 +1,247 @@
 #!/usr/bin/env python3
 # Copyright (c) 2015-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.
 """Test BIP65 (CHECKLOCKTIMEVERIFY).
 
 Test that the CHECKLOCKTIMEVERIFY soft-fork activates at (regtest) block height
 1351.
 """
 
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import *
 from test_framework.mininode import *
 from test_framework.blocktools import create_coinbase, create_block
 from test_framework.script import CScript, CScriptNum, OP_1NEGATE, OP_CHECKLOCKTIMEVERIFY, OP_DROP, OP_TRUE
 from test_framework.txtools import pad_tx
 
 CLTV_HEIGHT = 1351
 
 # Reject codes that we might receive in this test
 REJECT_INVALID = 16
 REJECT_OBSOLETE = 17
 REJECT_NONSTANDARD = 64
 
 
 def cltv_lock_to_height(node, tx, height=-1):
     '''Modify the scriptPubKey to add an OP_CHECKLOCKTIMEVERIFY
 
     This transforms the script to anyone can spend (OP_TRUE) if the lock time
     condition is valid.
 
     Default height is -1 which leads CLTV to fail
 
     TODO: test more ways that transactions using CLTV could be invalid (eg
     locktime requirements fail, sequence time requirements fail, etc).
     '''
     height_op = OP_1NEGATE
     if(height > 0):
         tx.vin[0].nSequence = 0
         tx.nLockTime = height
         height_op = CScriptNum(height)
 
     tx.vout[0].scriptPubKey = CScript(
         [height_op, OP_CHECKLOCKTIMEVERIFY, OP_DROP, OP_TRUE])
     tx.rehash()
 
     signed_result = node.signrawtransaction(ToHex(tx))
 
     new_tx = FromHex(CTransaction(), signed_result['hex'])
     pad_tx(new_tx)
     new_tx.rehash()
 
     return new_tx
 
 
 def spend_from_coinbase(node, coinbase, to_address, amount):
     from_txid = node.getblock(coinbase)['tx'][0]
     inputs = [{"txid": from_txid, "vout": 0}]
     outputs = {to_address: amount}
     rawtx = node.createrawtransaction(inputs, outputs)
     signresult = node.signrawtransaction(rawtx)
     tx = FromHex(CTransaction(), signresult['hex'])
     return tx
 
 
 class BIP65Test(BitcoinTestFramework):
     def set_test_params(self):
         self.num_nodes = 1
         self.extra_args = [
             ['-promiscuousmempoolflags=1', '-whitelist=127.0.0.1']]
         self.setup_clean_chain = True
 
     def run_test(self):
-        node0 = NodeConnCB()
-        connections = []
-        connections.append(
-            NodeConn('127.0.0.1', p2p_port(0), self.nodes[0], node0))
-        node0.add_connection(connections[0])
+        self.nodes[0].add_p2p_connection(NodeConnCB())
 
         # Start up network handling in another thread
         NetworkThread().start()
 
         # wait_for_verack ensures that the P2P connection is fully up.
-        node0.wait_for_verack()
+        self.nodes[0].p2p.wait_for_verack()
 
         self.log.info("Mining %d blocks", CLTV_HEIGHT - 2)
         self.coinbase_blocks = self.nodes[0].generate(CLTV_HEIGHT - 2)
         self.nodeaddress = self.nodes[0].getnewaddress()
 
         self.log.info(
             "Test that an invalid-according-to-CLTV transaction can still appear in a block")
 
         spendtx = spend_from_coinbase(self.nodes[0], self.coinbase_blocks[0],
                                       self.nodeaddress, 50.0)
         spendtx = cltv_lock_to_height(self.nodes[0], spendtx)
 
         # Make sure the tx is valid
         self.nodes[0].sendrawtransaction(ToHex(spendtx))
 
         tip = self.nodes[0].getbestblockhash()
         block_time = self.nodes[0].getblockheader(tip)['mediantime'] + 1
         block = create_block(int(tip, 16), create_coinbase(
             CLTV_HEIGHT - 1), block_time)
         block.nVersion = 3
         block.vtx.append(spendtx)
         block.hashMerkleRoot = block.calc_merkle_root()
         block.solve()
 
-        node0.send_and_ping(msg_block(block))
+        self.nodes[0].p2p.send_and_ping(msg_block(block))
         assert_equal(self.nodes[0].getbestblockhash(), block.hash)
 
         self.log.info("Test that blocks must now be at least version 4")
         tip = block.sha256
         block_time += 1
         block = create_block(tip, create_coinbase(CLTV_HEIGHT), block_time)
         block.nVersion = 3
         block.solve()
-        node0.send_and_ping(msg_block(block))
+        self.nodes[0].p2p.send_and_ping(msg_block(block))
         assert_equal(int(self.nodes[0].getbestblockhash(), 16), tip)
 
-        wait_until(lambda: "reject" in node0.last_message.keys(),
+        wait_until(lambda: "reject" in self.nodes[0].p2p.last_message.keys(),
                    lock=mininode_lock)
         with mininode_lock:
-            assert_equal(node0.last_message["reject"].code, REJECT_OBSOLETE)
             assert_equal(
-                node0.last_message["reject"].reason, b'bad-version(0x00000003)')
-            assert_equal(node0.last_message["reject"].data, block.sha256)
-            del node0.last_message["reject"]
+                self.nodes[0].p2p.last_message["reject"].code, REJECT_OBSOLETE)
+            assert_equal(
+                self.nodes[0].p2p.last_message["reject"].reason, b'bad-version(0x00000003)')
+            assert_equal(
+                self.nodes[0].p2p.last_message["reject"].data, block.sha256)
+            del self.nodes[0].p2p.last_message["reject"]
 
         self.log.info(
             "Test that invalid-according-to-cltv transactions cannot appear in a block")
         block.nVersion = 4
 
         spendtx = spend_from_coinbase(self.nodes[0], self.coinbase_blocks[1],
                                       self.nodeaddress, 49.99)
         spendtx = cltv_lock_to_height(self.nodes[0], spendtx)
 
         # First we show that this tx is valid except for CLTV by getting it
         # accepted to the mempool (which we can achieve with
         # -promiscuousmempoolflags).
-        node0.send_and_ping(msg_tx(spendtx))
+        self.nodes[0].p2p.send_and_ping(msg_tx(spendtx))
         assert spendtx.hash in self.nodes[0].getrawmempool()
 
         # Mine a block containing the funding transaction
         block.vtx.append(spendtx)
         block.hashMerkleRoot = block.calc_merkle_root()
         block.solve()
 
-        node0.send_and_ping(msg_block(block))
+        self.nodes[0].p2p.send_and_ping(msg_block(block))
         # This block is valid
         assert_equal(self.nodes[0].getbestblockhash(), block.hash)
 
         # But a block containing a transaction spending this utxo is not
         rawspendtx = self.nodes[0].decoderawtransaction(ToHex(spendtx))
         inputs = [{
             "txid": rawspendtx['txid'],
             "vout": rawspendtx['vout'][0]['n']
         }]
         output = {self.nodeaddress: 49.98}
 
         rejectedtx_raw = self.nodes[0].createrawtransaction(inputs, output)
         rejectedtx_signed = self.nodes[0].signrawtransaction(rejectedtx_raw)
 
         # Couldn't complete signature due to CLTV
         assert(rejectedtx_signed['errors'][0]['error'] == 'Negative locktime')
 
         rejectedtx = FromHex(CTransaction(), rejectedtx_signed['hex'])
         pad_tx(rejectedtx)
         rejectedtx.rehash()
 
         tip = block.hash
         block_time += 1
         block = create_block(
             block.sha256, create_coinbase(CLTV_HEIGHT+1), block_time)
         block.nVersion = 4
         block.vtx.append(rejectedtx)
         block.hashMerkleRoot = block.calc_merkle_root()
         block.solve()
 
-        node0.send_and_ping(msg_block(block))
+        self.nodes[0].p2p.send_and_ping(msg_block(block))
         # This block is invalid
         assert_equal(self.nodes[0].getbestblockhash(), tip)
 
-        wait_until(lambda: "reject" in node0.last_message.keys(),
+        wait_until(lambda: "reject" in self.nodes[0].p2p.last_message.keys(),
                    lock=mininode_lock)
         with mininode_lock:
-            assert node0.last_message["reject"].code in [
+            assert self.nodes[0].p2p.last_message["reject"].code in [
                 REJECT_INVALID, REJECT_NONSTANDARD]
-            assert_equal(node0.last_message["reject"].data, block.sha256)
-            if node0.last_message["reject"].code == REJECT_INVALID:
+            assert_equal(
+                self.nodes[0].p2p.last_message["reject"].data, block.sha256)
+            if self.nodes[0].p2p.last_message["reject"].code == REJECT_INVALID:
                 # Generic rejection when a block is invalid
                 assert_equal(
-                    node0.last_message["reject"].reason, b'blk-bad-inputs')
+                    self.nodes[0].p2p.last_message["reject"].reason, b'blk-bad-inputs')
             else:
-                assert b'Negative locktime' in node0.last_message["reject"].reason
+                assert b'Negative locktime' in self.nodes[0].p2p.last_message["reject"].reason
 
         self.log.info(
             "Test that a version 4 block with a valid-according-to-CLTV transaction is accepted")
         spendtx = spend_from_coinbase(self.nodes[0], self.coinbase_blocks[2],
                                       self.nodeaddress, 49.99)
         spendtx = cltv_lock_to_height(self.nodes[0], spendtx, CLTV_HEIGHT - 1)
 
         # Modify the transaction in the block to be valid against CLTV
         block.vtx.pop(1)
         block.vtx.append(spendtx)
         block.hashMerkleRoot = block.calc_merkle_root()
         block.solve()
 
-        node0.send_and_ping(msg_block(block))
+        self.nodes[0].p2p.send_and_ping(msg_block(block))
         # This block is now valid
         assert_equal(self.nodes[0].getbestblockhash(), block.hash)
 
         # A block containing a transaction spending this utxo is also valid
         # Build this transaction
         rawspendtx = self.nodes[0].decoderawtransaction(ToHex(spendtx))
         inputs = [{
             "txid": rawspendtx['txid'],
             "vout": rawspendtx['vout'][0]['n'],
             "sequence": 0
         }]
         output = {self.nodeaddress: 49.98}
 
         validtx_raw = self.nodes[0].createrawtransaction(
             inputs, output, CLTV_HEIGHT)
 
         validtx = FromHex(CTransaction(), validtx_raw)
 
         # Signrawtransaction won't sign a non standard tx.
         # But the prevout being anyone can spend, scriptsig can be left empty
         validtx.vin[0].scriptSig = CScript()
         pad_tx(validtx)
         validtx.rehash()
 
         tip = block.sha256
         block_time += 1
         block = create_block(tip, create_coinbase(CLTV_HEIGHT+3), block_time)
         block.nVersion = 4
         block.vtx.append(validtx)
         block.hashMerkleRoot = block.calc_merkle_root()
         block.solve()
 
-        node0.send_and_ping(msg_block(block))
+        self.nodes[0].p2p.send_and_ping(msg_block(block))
         # This block is valid
         assert_equal(self.nodes[0].getbestblockhash(), block.hash)
 
 
 if __name__ == '__main__':
     BIP65Test().main()
diff --git a/test/functional/bipdersig-p2p.py b/test/functional/bipdersig-p2p.py
index 46d54898d1..eee69b1534 100755
--- a/test/functional/bipdersig-p2p.py
+++ b/test/functional/bipdersig-p2p.py
@@ -1,145 +1,146 @@
 #!/usr/bin/env python3
 # Copyright (c) 2015-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.
 """Test BIP66 (DER SIG).
 
 Test that the DERSIG soft-fork activates at (regtest) height 1251.
 """
 
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import *
 from test_framework.mininode import *
 from test_framework.blocktools import create_coinbase, create_block
 from test_framework.script import CScript
 from io import BytesIO
 
 DERSIG_HEIGHT = 1251
 
 # Reject codes that we might receive in this test
 REJECT_INVALID = 16
 REJECT_OBSOLETE = 17
 REJECT_NONSTANDARD = 64
 
 # A canonical signature consists of:
 # <30> <total len> <02> <len R> <R> <02> <len S> <S> <hashtype>
 
 
 def unDERify(tx):
     """
     Make the signature in vin 0 of a tx non-DER-compliant,
     by adding padding after the S-value.
     """
     scriptSig = CScript(tx.vin[0].scriptSig)
     newscript = []
     for i in scriptSig:
         if (len(newscript) == 0):
             newscript.append(i[0:-1] + b'\0' + i[-1:])
         else:
             newscript.append(i)
     tx.vin[0].scriptSig = CScript(newscript)
 
 
 def create_transaction(node, coinbase, to_address, amount):
     from_txid = node.getblock(coinbase)['tx'][0]
     inputs = [{"txid": from_txid, "vout": 0}]
     outputs = {to_address: amount}
     rawtx = node.createrawtransaction(inputs, outputs)
     signresult = node.signrawtransaction(rawtx)
     tx = CTransaction()
     tx.deserialize(BytesIO(hex_str_to_bytes(signresult['hex'])))
     return tx
 
 
 class BIP66Test(BitcoinTestFramework):
     def set_test_params(self):
         self.num_nodes = 1
         self.extra_args = [
             ['-promiscuousmempoolflags=1', '-whitelist=127.0.0.1']]
         self.setup_clean_chain = True
 
     def run_test(self):
-        node0 = NodeConnCB()
-        connections = []
-        connections.append(
-            NodeConn('127.0.0.1', p2p_port(0), self.nodes[0], node0))
-        node0.add_connection(connections[0])
-        NetworkThread().start()  # Start up network handling in another thread
+        self.nodes[0].add_p2p_connection(NodeConnCB())
+
+        # Start up network handling in another thread
+        NetworkThread().start()
 
         # wait_for_verack ensures that the P2P connection is fully up.
-        node0.wait_for_verack()
+        self.nodes[0].p2p.wait_for_verack()
 
         self.log.info("Mining %d blocks", DERSIG_HEIGHT - 1)
         self.coinbase_blocks = self.nodes[0].generate(DERSIG_HEIGHT - 1)
         self.nodeaddress = self.nodes[0].getnewaddress()
 
         self.log.info("Test that blocks must now be at least version 3")
         tip = self.nodes[0].getbestblockhash()
         block_time = self.nodes[0].getblockheader(tip)['mediantime'] + 1
         block = create_block(
             int(tip, 16), create_coinbase(DERSIG_HEIGHT), block_time)
         block.nVersion = 2
         block.rehash()
         block.solve()
-        node0.send_and_ping(msg_block(block))
+        self.nodes[0].p2p.send_and_ping(msg_block(block))
         assert_equal(self.nodes[0].getbestblockhash(), tip)
 
-        wait_until(lambda: "reject" in node0.last_message.keys(),
+        wait_until(lambda: "reject" in self.nodes[0].p2p.last_message.keys(),
                    lock=mininode_lock)
         with mininode_lock:
-            assert_equal(node0.last_message["reject"].code, REJECT_OBSOLETE)
             assert_equal(
-                node0.last_message["reject"].reason, b'bad-version(0x00000002)')
-            assert_equal(node0.last_message["reject"].data, block.sha256)
-            del node0.last_message["reject"]
+                self.nodes[0].p2p.last_message["reject"].code, REJECT_OBSOLETE)
+            assert_equal(
+                self.nodes[0].p2p.last_message["reject"].reason, b'bad-version(0x00000002)')
+            assert_equal(
+                self.nodes[0].p2p.last_message["reject"].data, block.sha256)
+            del self.nodes[0].p2p.last_message["reject"]
 
         self.log.info(
             "Test that transactions with non-DER signatures cannot appear in a block")
         block.nVersion = 3
 
         spendtx = create_transaction(self.nodes[0], self.coinbase_blocks[1],
                                      self.nodeaddress, 1.0)
         unDERify(spendtx)
         spendtx.rehash()
 
         # Now we verify that a block with this transaction is invalid.
         block.vtx.append(spendtx)
         block.hashMerkleRoot = block.calc_merkle_root()
         block.rehash()
         block.solve()
 
-        node0.send_and_ping(msg_block(block))
+        self.nodes[0].p2p.send_and_ping(msg_block(block))
         assert_equal(self.nodes[0].getbestblockhash(), tip)
 
-        wait_until(lambda: "reject" in node0.last_message.keys(),
+        wait_until(lambda: "reject" in self.nodes[0].p2p.last_message.keys(),
                    lock=mininode_lock)
         with mininode_lock:
             # We can receive different reject messages depending on whether
             # bitcoind is running with multiple script check threads. If script
             # check threads are not in use, then transaction script validation
             # happens sequentially, and bitcoind produces more specific reject
             # reasons.
-            assert node0.last_message["reject"].code in [
+            assert self.nodes[0].p2p.last_message["reject"].code in [
                 REJECT_INVALID, REJECT_NONSTANDARD]
-            assert_equal(node0.last_message["reject"].data, block.sha256)
-            if node0.last_message["reject"].code == REJECT_INVALID:
+            assert_equal(
+                self.nodes[0].p2p.last_message["reject"].data, block.sha256)
+            if self.nodes[0].p2p.last_message["reject"].code == REJECT_INVALID:
                 # Generic rejection when a block is invalid
                 assert_equal(
-                    node0.last_message["reject"].reason, b'blk-bad-inputs')
+                    self.nodes[0].p2p.last_message["reject"].reason, b'blk-bad-inputs')
             else:
-                assert b'Non-canonical DER signature' in node0.last_message["reject"].reason
+                assert b'Non-canonical DER signature' in self.nodes[0].p2p.last_message["reject"].reason
 
         self.log.info(
             "Test that a version 3 block with a DERSIG-compliant transaction is accepted")
         block.vtx[1] = create_transaction(self.nodes[0],
                                           self.coinbase_blocks[1], self.nodeaddress, 1.0)
         block.hashMerkleRoot = block.calc_merkle_root()
         block.rehash()
         block.solve()
 
-        node0.send_and_ping(msg_block(block))
+        self.nodes[0].p2p.send_and_ping(msg_block(block))
         assert_equal(int(self.nodes[0].getbestblockhash(), 16), block.sha256)
 
 
 if __name__ == '__main__':
     BIP66Test().main()