diff --git a/bench-tps/src/bench.rs b/bench-tps/src/bench.rs
index 83a6b746f..778196f09 100644
--- a/bench-tps/src/bench.rs
+++ b/bench-tps/src/bench.rs
@@ -11,8 +11,6 @@ use solana_client::thin_client::ThinClient;
 use solana_drone::drone::request_airdrop_transaction;
 use solana_metrics::influxdb;
 use solana_sdk::client::{AsyncClient, SyncClient};
-use solana_sdk::hash::Hash;
-use solana_sdk::pubkey::Pubkey;
 use solana_sdk::signature::{Keypair, KeypairUtil};
 use solana_sdk::system_instruction;
 use solana_sdk::system_transaction;
@@ -68,8 +66,6 @@ pub fn do_bench_tps(config: Config) {
     let cluster_entrypoint = nodes[0].clone(); // Pick the first node, why not?
 
     let client = create_client(cluster_entrypoint.client_facing_addr(), FULLNODE_PORT_RANGE);
-    let mut barrier_client =
-        create_client(cluster_entrypoint.client_facing_addr(), FULLNODE_PORT_RANGE);
 
     let mut seed = [0u8; 32];
     seed.copy_from_slice(&id.public_key_bytes()[..32]);
@@ -83,8 +79,6 @@ pub fn do_bench_tps(config: Config) {
         target /= MAX_SPENDS_PER_TX;
     }
     let gen_keypairs = rnd.gen_n_keypairs(total_keys as u64);
-    let barrier_source_keypair = Keypair::new();
-    let barrier_dest_id = Pubkey::new_rand();
 
     println!("Get lamports...");
     let num_lamports_per_account = 20;
@@ -104,11 +98,6 @@ pub fn do_bench_tps(config: Config) {
     }
     let start = gen_keypairs.len() - (tx_count * 2) as usize;
     let keypairs = &gen_keypairs[start..];
-    airdrop_lamports(&barrier_client, &drone_addr, &barrier_source_keypair, 1);
-
-    println!("Get last ID...");
-    let mut blockhash = client.get_recent_blockhash().unwrap();
-    println!("Got last ID {:?}", blockhash);
 
     let first_tx_count = client.get_transaction_count().expect("transaction count");
     println!("Initial transaction count {}", first_tx_count);
@@ -190,15 +179,6 @@ pub fn do_bench_tps(config: Config) {
                 sleep(Duration::from_millis(100));
             }
         }
-        // It's not feasible (would take too much time) to confirm each of the `tx_count / 2`
-        // transactions sent by `generate_txs()` so instead send and confirm a single transaction
-        // to validate the network is still functional.
-        send_barrier_transaction(
-            &mut barrier_client,
-            &mut blockhash,
-            &barrier_source_keypair,
-            &barrier_dest_id,
-        );
 
         i += 1;
         if should_switch_directions(num_lamports_per_account, i) {
@@ -301,82 +281,6 @@ fn sample_tx_count(
     }
 }
 
-/// Send loopback payment of 0 lamports and confirm the network processed it
-fn send_barrier_transaction(
-    barrier_client: &mut ThinClient,
-    blockhash: &mut Hash,
-    source_keypair: &Keypair,
-    dest_id: &Pubkey,
-) {
-    let transfer_start = Instant::now();
-
-    let mut poll_count = 0;
-    loop {
-        if poll_count > 0 && poll_count % 8 == 0 {
-            println!(
-                "polling for barrier transaction confirmation, attempt {}",
-                poll_count
-            );
-        }
-
-        *blockhash = barrier_client.get_recent_blockhash().unwrap();
-
-        let transaction =
-            system_transaction::create_user_account(&source_keypair, dest_id, 0, *blockhash, 0);
-        let signature = barrier_client
-            .async_send_transaction(transaction)
-            .expect("Unable to send barrier transaction");
-
-        let confirmatiom = barrier_client.poll_for_signature(&signature);
-        let duration_ms = duration_as_ms(&transfer_start.elapsed());
-        if confirmatiom.is_ok() {
-            println!("barrier transaction confirmed in {} ms", duration_ms);
-
-            solana_metrics::submit(
-                influxdb::Point::new("bench-tps")
-                    .add_tag(
-                        "op",
-                        influxdb::Value::String("send_barrier_transaction".to_string()),
-                    )
-                    .add_field("poll_count", influxdb::Value::Integer(poll_count))
-                    .add_field("duration", influxdb::Value::Integer(duration_ms as i64))
-                    .to_owned(),
-            );
-
-            // Sanity check that the client balance is still 1
-            let balance = barrier_client
-                .poll_balance_with_timeout(
-                    &source_keypair.pubkey(),
-                    &Duration::from_millis(100),
-                    &Duration::from_secs(10),
-                )
-                .expect("Failed to get balance");
-            if balance != 1 {
-                panic!("Expected an account balance of 1 (balance: {}", balance);
-            }
-            break;
-        }
-
-        // Timeout after 3 minutes.  When running a CPU-only leader+validator+drone+bench-tps on a dev
-        // machine, some batches of transactions can take upwards of 1 minute...
-        if duration_ms > 1000 * 60 * 3 {
-            println!("Error: Couldn't confirm barrier transaction!");
-            exit(1);
-        }
-
-        let new_blockhash = barrier_client.get_recent_blockhash().unwrap();
-        if new_blockhash == *blockhash {
-            if poll_count > 0 && poll_count % 8 == 0 {
-                println!("blockhash is not advancing, still at {:?}", *blockhash);
-            }
-        } else {
-            *blockhash = new_blockhash;
-        }
-
-        poll_count += 1;
-    }
-}
-
 fn generate_txs(
     shared_txs: &SharedTransactions,
     source: &[Keypair],