diff --git a/contrib/zmq/zmq_sub.py b/contrib/zmq/zmq_sub.py
index 8f0dc753d..42ce17ac4 100755
--- a/contrib/zmq/zmq_sub.py
+++ b/contrib/zmq/zmq_sub.py
@@ -1,96 +1,96 @@
 #!/usr/bin/env python3
 # Copyright (c) 2014-2017 The Bitcoin Core developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 """
     ZMQ example using python3's asyncio
 
     Bitcoin should be started with the command line arguments:
         bitcoind -testnet -daemon \
                 -zmqpubrawtx=tcp://127.0.0.1:28332 \
                 -zmqpubrawblock=tcp://127.0.0.1:28332 \
                 -zmqpubhashtx=tcp://127.0.0.1:28332 \
                 -zmqpubhashblock=tcp://127.0.0.1:28332 \
                 -zmqpubsequence=tcp://127.0.0.1:28332
 
     We use the asyncio library here.  `self.handle()` installs itself as a
     future at the end of the function.  Since it never returns with the event
     loop having an empty stack of futures, this creates an infinite loop.  An
     alternative is to wrap the contents of `handle` inside `while True`.
 
     A blocking example using python 2.7 can be obtained from the git history:
     https://github.com/bitcoin/bitcoin/blob/37a7fe9e440b83e2364d5498931253937abe9294/contrib/zmq/zmq_sub.py
 """
 
 import asyncio
 import binascii
 import signal
 import struct
 import sys
 
 import zmq.asyncio
 
 import zmq
 
 if (sys.version_info.major, sys.version_info.minor) < (3, 6):
     print("This example only works with Python 3.6 and greater")
     sys.exit(1)
 
 port = 28332
 ip = "127.0.0.1"
 
 
 class ZMQHandler():
     def __init__(self):
         self.loop = asyncio.get_event_loop()
         self.zmqContext = zmq.asyncio.Context()
 
         self.zmqSubSocket = self.zmqContext.socket(zmq.SUB)
         self.zmqSubSocket.setsockopt(zmq.RCVHWM, 0)
         self.zmqSubSocket.setsockopt_string(zmq.SUBSCRIBE, "hashblock")
         self.zmqSubSocket.setsockopt_string(zmq.SUBSCRIBE, "hashtx")
         self.zmqSubSocket.setsockopt_string(zmq.SUBSCRIBE, "rawblock")
         self.zmqSubSocket.setsockopt_string(zmq.SUBSCRIBE, "rawtx")
         self.zmqSubSocket.setsockopt_string(zmq.SUBSCRIBE, "sequence")
         self.zmqSubSocket.connect(f"tcp://{ip}:{port}")
 
     async def handle(self):
         topic, body, seq = await self.zmqSubSocket.recv_multipart()
         sequence = "Unknown"
         if len(seq) == 4:
             sequence = str(struct.unpack('<I', seq)[-1])
         if topic == b"hashblock":
             print(f'- HASH BLOCK ({sequence}) -')
             print(binascii.hexlify(body))
         elif topic == b"hashtx":
             print(f'- HASH TX  ({sequence}) -')
             print(binascii.hexlify(body))
         elif topic == b"rawblock":
             print(f'- RAW BLOCK HEADER ({sequence}) -')
             print(binascii.hexlify(body[:80]))
         elif topic == b"rawtx":
             print(f'- RAW TX ({sequence}) -')
             print(binascii.hexlify(body))
         elif topic == b"sequence":
-            hash = binascii.hexlify(body[:32])
+            item_hash = binascii.hexlify(body[:32])
             label = chr(body[32])
             mempool_sequence = (None if len(body) != 32 + 1 + 8 else
                                 struct.unpack("<Q", body[32 + 1:])[0])
             print('- SEQUENCE (' + sequence + ') -')
-            print(hash, label, mempool_sequence)
+            print(item_hash, label, mempool_sequence)
         # schedule ourselves to receive the next message
         asyncio.ensure_future(self.handle())
 
     def start(self):
         self.loop.add_signal_handler(signal.SIGINT, self.stop)
         self.loop.create_task(self.handle())
         self.loop.run_forever()
 
     def stop(self):
         self.loop.stop()
         self.zmqContext.destroy()
 
 
 daemon = ZMQHandler()
 daemon.start()