diff --git a/bin/pg_backrest_remote.pl b/bin/pg_backrest_remote.pl
index f8264f35f..d873cdc69 100755
--- a/bin/pg_backrest_remote.pl
+++ b/bin/pg_backrest_remote.pl
@@ -205,12 +205,13 @@ while ($strCommand ne OP_EXIT)
         # Archive push checks
         elsif ($strCommand eq OP_ARCHIVE_PUSH_CHECK)
         {
-            $oArchive->pushCheck($oFile,
-                                 param_get(\%oParamHash, 'wal-segment'),
-                                 param_get(\%oParamHash, 'db-version'),
-                                 param_get(\%oParamHash, 'db-sys-id'));
+            my $strChecksum = $oArchive->pushCheck($oFile,
+                                                   param_get(\%oParamHash, 'wal-segment'),
+                                                   undef,
+                                                   param_get(\%oParamHash, 'db-version'),
+                                                   param_get(\%oParamHash, 'db-sys-id'));
 
-            $oRemote->output_write('Y');
+            $oRemote->output_write(defined($strChecksum) ? $strChecksum : 'Y');
         }
         # Continue if noop or exit
         elsif ($strCommand ne OP_NOOP && $strCommand ne OP_EXIT)
diff --git a/lib/BackRest/Archive.pm b/lib/BackRest/Archive.pm
index e08ffe347..3e3c40d78 100644
--- a/lib/BackRest/Archive.pm
+++ b/lib/BackRest/Archive.pm
@@ -464,7 +464,7 @@ sub push
     if ($bArchiveFile && !$bAsync)
     {
         my ($strDbVersion, $ullDbSysId) = $self->walInfo($strSourceFile);
-        $self->pushCheck($oFile, substr(basename($strSourceFile), 0, 24), $strDbVersion, $ullDbSysId);
+        $self->pushCheck($oFile, substr(basename($strSourceFile), 0, 24), $strSourceFile, $strDbVersion, $ullDbSysId);
     }
 
     # Append compression extension
@@ -493,12 +493,14 @@ sub pushCheck
     my $self = shift;
     my $oFile = shift;
     my $strWalSegment = shift;
+    my $strWalFile = shift;
     my $strDbVersion = shift;
     my $ullDbSysId = shift;
 
     # Set operation and debug strings
     my $strOperation = OP_ARCHIVE_PUSH_CHECK;
     &log(DEBUG, "${strOperation}: " . PATH_BACKUP_ARCHIVE . ":${strWalSegment}");
+    my $strChecksum;
 
     if ($oFile->is_remote(PATH_BACKUP_ARCHIVE))
     {
@@ -513,7 +515,12 @@ sub pushCheck
         &log(TRACE, "${strOperation}: remote (" . $oFile->{oRemote}->command_param_string(\%oParamHash) . ')');
 
         # Execute the command
-        $oFile->{oRemote}->command_execute($strOperation, \%oParamHash);
+        $strChecksum = $oFile->{oRemote}->command_execute($strOperation, \%oParamHash, true);
+
+        if ($strChecksum eq 'Y')
+        {
+            undef($strChecksum);
+        }
     }
     else
     {
@@ -551,11 +558,30 @@ sub pushCheck
         }
 
         # Check if the WAL segment already exists in the archive
-        if (defined($self->walFileName($oFile, $strWalSegment)))
+        $strChecksum = $self->walFileName($oFile, $strWalSegment);
+
+        if (defined($strChecksum))
+        {
+            $strChecksum = substr($strChecksum, 25, 40);
+        }
+    }
+
+    if (defined($strChecksum) && defined($strWalFile))
+    {
+        my $strChecksumNew = $oFile->hash(PATH_DB_ABSOLUTE, $strWalFile);
+
+        if ($strChecksumNew ne $strChecksum)
         {
             confess &log(ERROR, "WAL segment ${strWalSegment} already exists in the archive", ERROR_ARCHIVE_DUPLICATE);
         }
+
+        &log(WARN, "WAL segment ${strWalSegment} already exists in the archive with the same checksum" .
+                   " - this is valid in some recovery scenarios but may also indicate a problem");
+
+        return undef;
     }
+
+    return $strChecksum;
 }
 
 ####################################################################################################################################
@@ -670,7 +696,7 @@ sub xfer
         if ($bArchiveFile)
         {
             my ($strDbVersion, $ullDbSysId) = $self->walInfo($strArchiveFile);
-            $self->pushCheck($oFile, substr(basename($strArchiveFile), 0, 24), $strDbVersion, $ullDbSysId);
+            $self->pushCheck($oFile, substr(basename($strArchiveFile), 0, 24), $strArchiveFile, $strDbVersion, $ullDbSysId);
         }
 
         # Copy the archive file
diff --git a/test/data/test.archive1.bin b/test/data/test.archive1.bin
index 7b9db308f..5e48f9a78 100644
Binary files a/test/data/test.archive1.bin and b/test/data/test.archive1.bin differ
diff --git a/test/lib/BackRestTest/BackupTest.pm b/test/lib/BackRestTest/BackupTest.pm
index edadf5b7a..88d3b8fc7 100755
--- a/test/lib/BackRestTest/BackupTest.pm
+++ b/test/lib/BackRestTest/BackupTest.pm
@@ -1489,6 +1489,7 @@ sub BackRestTestBackup_Test
     my $iArchiveMax = 3;
     my $strXlogPath = BackRestTestCommon_DbCommonPathGet() . '/pg_xlog';
     my $strArchiveTestFile = BackRestTestCommon_DataPathGet() . '/test.archive2.bin';
+    my $strArchiveTestFile2 = BackRestTestCommon_DataPathGet() . '/test.archive1.bin';
 
     # Print test banner
     &log(INFO, 'BACKUP MODULE ******************************************************************');
@@ -1640,9 +1641,21 @@ sub BackRestTestBackup_Test
                             $oInfo{database}{'system-id'} = $ullDbSysId;
                             BackRestTestCommon_iniSave($strInfoFile, \%oInfo, $bRemote);
 
-                            # Now it should break on archive duplication
+                            # Should succeed because checksum is the same
+                            &log(INFO, '        test archive duplicate ok');
+
+                            BackRestTestCommon_Execute($strCommand . " ${strSourceFile}");
+
+                            # Now it should break on archive duplication (because checksum is different
                             &log(INFO, '        test archive duplicate error');
 
+                            $oFile->copy(PATH_DB_ABSOLUTE, $strArchiveTestFile2, # Source file
+                                         PATH_DB_ABSOLUTE, $strSourceFile,       # Destination file
+                                         false,                                  # Source is not compressed
+                                         false,                                  # Destination is not compressed
+                                         undef, undef, undef,                    # Unused params
+                                         true);                                  # Create path if it does not exist
+
                             BackRestTestCommon_Execute($strCommand . " ${strSourceFile}", undef, undef, undef,
                                                        ERROR_ARCHIVE_DUPLICATE);
 
@@ -1650,7 +1663,7 @@ sub BackRestTestBackup_Test
                             {
                                 my $strDuplicateWal =
                                     ($bRemote ? BackRestTestCommon_LocalPathGet() : BackRestTestCommon_RepoPathGet()) .
-                                    "/archive/${strStanza}/out/${strArchiveFile}-1c7e00fd09b9dd11fc2966590b3e3274645dd031";
+                                    "/archive/${strStanza}/out/${strArchiveFile}-4518a0fdf41d796760b384a358270d4682589820";
 
                                 unlink ($strDuplicateWal)
                                         or confess "unable to remove duplicate WAL segment created for testing: ${strDuplicateWal}";
diff --git a/test/lib/BackRestTest/FileTest.pm b/test/lib/BackRestTest/FileTest.pm
index 676435dc0..4d0a29162 100755
--- a/test/lib/BackRestTest/FileTest.pm
+++ b/test/lib/BackRestTest/FileTest.pm
@@ -1153,7 +1153,7 @@ sub BackRestTestFile_Test
 
                     if ($iLarge == 1)
                     {
-                        $strSourceHash = 'c2e63b6a49d53a53d6df1aa6b70c7c16747ca099';
+                        $strSourceHash = '4518a0fdf41d796760b384a358270d4682589820';
                         $iSourceSize = 16777216;
                     }
                     elsif ($iLarge == 2)
diff --git a/test/log/backup-archive-push-001.log b/test/log/backup-archive-push-001.log
index 3a114500e..2d896fa5d 100644
--- a/test/log/backup-archive-push-001.log
+++ b/test/log/backup-archive-push-001.log
@@ -41,6 +41,20 @@ run 001 - rmt 0, cmp 0, arc_async 0
  DEBUG:     File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
  DEBUG:     File->exists: backup:archive:[TEST_PATH]/backrest/archive/db/archive.info
  DEBUG:     File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/0000000100000001, expression ^000000010000000100000001(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
+ DEBUG:     File->hash: db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000001, compressed = false, hash_type = sha1
+  WARN: WAL segment 000000010000000100000001 already exists in the archive with the same checksum - this is valid in some recovery scenarios but may also indicate a problem
+ DEBUG:     File->copy:  local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000001 to local backup:archive:[TEST_PATH]/backrest/archive/db/0000000100000001/000000010000000100000001, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = [undef], user = [undef], group = [undef]
+ DEBUG:     File->move: absolute:[TEST_PATH]/backrest/archive/db/0000000100000001/000000010000000100000001.tmp to absolute:[TEST_PATH]/backrest/archive/db/0000000100000001/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031, destination_path_create = true
+ DEBUG:     safe exit called, terminating threads
+
+> ../bin/pg_backrest.pl --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
+------------------------------------------------------------------------------------------------------------------------------------
+  INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
+ DEBUG:     Archive->pushCheck: backup:archive:000000010000000100000001
+ DEBUG:     File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
+ DEBUG:     File->exists: backup:archive:[TEST_PATH]/backrest/archive/db/archive.info
+ DEBUG:     File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/0000000100000001, expression ^000000010000000100000001(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
+ DEBUG:     File->hash: db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000001, compressed = false, hash_type = sha1
  ERROR: [120]: WAL segment 000000010000000100000001 already exists in the archive
  DEBUG:     safe exit called, terminating threads
 
@@ -113,6 +127,20 @@ run 001 - rmt 0, cmp 0, arc_async 0
  DEBUG:     File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
  DEBUG:     File->exists: backup:archive:[TEST_PATH]/backrest/archive/db/archive.info
  DEBUG:     File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/0000000100000001, expression ^000000010000000100000005(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
+ DEBUG:     File->hash: db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000005, compressed = false, hash_type = sha1
+  WARN: WAL segment 000000010000000100000005 already exists in the archive with the same checksum - this is valid in some recovery scenarios but may also indicate a problem
+ DEBUG:     File->copy:  local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000005 to local backup:archive:[TEST_PATH]/backrest/archive/db/0000000100000001/000000010000000100000005, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = [undef], user = [undef], group = [undef]
+ DEBUG:     File->move: absolute:[TEST_PATH]/backrest/archive/db/0000000100000001/000000010000000100000005.tmp to absolute:[TEST_PATH]/backrest/archive/db/0000000100000001/000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031, destination_path_create = true
+ DEBUG:     safe exit called, terminating threads
+
+> ../bin/pg_backrest.pl --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
+------------------------------------------------------------------------------------------------------------------------------------
+  INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
+ DEBUG:     Archive->pushCheck: backup:archive:000000010000000100000005
+ DEBUG:     File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
+ DEBUG:     File->exists: backup:archive:[TEST_PATH]/backrest/archive/db/archive.info
+ DEBUG:     File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/0000000100000001, expression ^000000010000000100000005(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
+ DEBUG:     File->hash: db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000005, compressed = false, hash_type = sha1
  ERROR: [120]: WAL segment 000000010000000100000005 already exists in the archive
  DEBUG:     safe exit called, terminating threads
 
@@ -185,5 +213,19 @@ run 001 - rmt 0, cmp 0, arc_async 0
  DEBUG:     File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
  DEBUG:     File->exists: backup:archive:[TEST_PATH]/backrest/archive/db/archive.info
  DEBUG:     File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/0000000100000001, expression ^000000010000000100000009(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
+ DEBUG:     File->hash: db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000009, compressed = false, hash_type = sha1
+  WARN: WAL segment 000000010000000100000009 already exists in the archive with the same checksum - this is valid in some recovery scenarios but may also indicate a problem
+ DEBUG:     File->copy:  local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000009 to local backup:archive:[TEST_PATH]/backrest/archive/db/0000000100000001/000000010000000100000009, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = [undef], user = [undef], group = [undef]
+ DEBUG:     File->move: absolute:[TEST_PATH]/backrest/archive/db/0000000100000001/000000010000000100000009.tmp to absolute:[TEST_PATH]/backrest/archive/db/0000000100000001/000000010000000100000009-1c7e00fd09b9dd11fc2966590b3e3274645dd031, destination_path_create = true
+ DEBUG:     safe exit called, terminating threads
+
+> ../bin/pg_backrest.pl --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
+------------------------------------------------------------------------------------------------------------------------------------
+  INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
+ DEBUG:     Archive->pushCheck: backup:archive:000000010000000100000009
+ DEBUG:     File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
+ DEBUG:     File->exists: backup:archive:[TEST_PATH]/backrest/archive/db/archive.info
+ DEBUG:     File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/0000000100000001, expression ^000000010000000100000009(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
+ DEBUG:     File->hash: db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000009, compressed = false, hash_type = sha1
  ERROR: [120]: WAL segment 000000010000000100000009 already exists in the archive
  DEBUG:     safe exit called, terminating threads
diff --git a/test/log/backup-archive-push-002.log b/test/log/backup-archive-push-002.log
index 820d22645..f8bdb2b0f 100644
--- a/test/log/backup-archive-push-002.log
+++ b/test/log/backup-archive-push-002.log
@@ -74,6 +74,31 @@ run 002 - rmt 0, cmp 0, arc_async 1
  DEBUG:     File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
  DEBUG:     File->exists: backup:archive:[TEST_PATH]/backrest/archive/db/archive.info
  DEBUG:     File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/0000000100000001, expression ^000000010000000100000001(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
+ DEBUG:     File->hash: db:absolute:[TEST_PATH]/backrest/archive/db/out/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031, compressed = false, hash_type = sha1
+  WARN: WAL segment 000000010000000100000001 already exists in the archive with the same checksum - this is valid in some recovery scenarios but may also indicate a problem
+ DEBUG:     File->copy:  local db:absolute:[TEST_PATH]/backrest/archive/db/out/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031 to local backup:archive:[TEST_PATH]/backrest/archive/db/0000000100000001/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = [undef], user = [undef], group = [undef]
+ DEBUG:     File->move: absolute:[TEST_PATH]/backrest/archive/db/0000000100000001/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031.tmp to absolute:[TEST_PATH]/backrest/archive/db/0000000100000001/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031, destination_path_create = true
+ DEBUG:     1 WAL segments were transferred, calling Archive->xfer() again
+ DEBUG:     File->manifest: db:absolute:[TEST_PATH]/backrest/archive/db/out
+ DEBUG:     no archive logs to be copied to backup
+ DEBUG:     no more WAL segments to transfer - exiting
+ DEBUG:     safe exit called, terminating threads
+
+> ../bin/pg_backrest.pl --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
+------------------------------------------------------------------------------------------------------------------------------------
+  INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000001 asynchronously
+ DEBUG:     File->copy:  local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000001 to local backup:archive:out:[TEST_PATH]/backrest/archive/db/out/000000010000000100000001, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = [undef], user = [undef], group = [undef]
+ DEBUG:     File->move: absolute:[TEST_PATH]/backrest/archive/db/out/000000010000000100000001.tmp to absolute:[TEST_PATH]/backrest/archive/db/out/000000010000000100000001-4518a0fdf41d796760b384a358270d4682589820, destination_path_create = true
+  INFO: No fork on archive local for TESTING
+  INFO: starting async archive-push
+ DEBUG:     File->manifest: db:absolute:[TEST_PATH]/backrest/archive/db/out
+  INFO: archive to be copied to backup total 1, size 16MB
+ DEBUG:     archive 000000010000000100000001-4518a0fdf41d796760b384a358270d4682589820, is WAL 1, source_compressed = 0, destination_compress 0, default_compress = 0
+ DEBUG:     Archive->pushCheck: backup:archive:000000010000000100000001
+ DEBUG:     File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
+ DEBUG:     File->exists: backup:archive:[TEST_PATH]/backrest/archive/db/archive.info
+ DEBUG:     File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/0000000100000001, expression ^000000010000000100000001(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
+ DEBUG:     File->hash: db:absolute:[TEST_PATH]/backrest/archive/db/out/000000010000000100000001-4518a0fdf41d796760b384a358270d4682589820, compressed = false, hash_type = sha1
  ERROR: [120]: WAL segment 000000010000000100000001 already exists in the archive
  DEBUG:     safe exit called, terminating threads
 
@@ -211,6 +236,31 @@ run 002 - rmt 0, cmp 0, arc_async 1
  DEBUG:     File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
  DEBUG:     File->exists: backup:archive:[TEST_PATH]/backrest/archive/db/archive.info
  DEBUG:     File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/0000000100000001, expression ^000000010000000100000005(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
+ DEBUG:     File->hash: db:absolute:[TEST_PATH]/backrest/archive/db/out/000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031, compressed = false, hash_type = sha1
+  WARN: WAL segment 000000010000000100000005 already exists in the archive with the same checksum - this is valid in some recovery scenarios but may also indicate a problem
+ DEBUG:     File->copy:  local db:absolute:[TEST_PATH]/backrest/archive/db/out/000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031 to local backup:archive:[TEST_PATH]/backrest/archive/db/0000000100000001/000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = [undef], user = [undef], group = [undef]
+ DEBUG:     File->move: absolute:[TEST_PATH]/backrest/archive/db/0000000100000001/000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031.tmp to absolute:[TEST_PATH]/backrest/archive/db/0000000100000001/000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031, destination_path_create = true
+ DEBUG:     1 WAL segments were transferred, calling Archive->xfer() again
+ DEBUG:     File->manifest: db:absolute:[TEST_PATH]/backrest/archive/db/out
+ DEBUG:     no archive logs to be copied to backup
+ DEBUG:     no more WAL segments to transfer - exiting
+ DEBUG:     safe exit called, terminating threads
+
+> ../bin/pg_backrest.pl --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
+------------------------------------------------------------------------------------------------------------------------------------
+  INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000005 asynchronously
+ DEBUG:     File->copy:  local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000005 to local backup:archive:out:[TEST_PATH]/backrest/archive/db/out/000000010000000100000005, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = [undef], user = [undef], group = [undef]
+ DEBUG:     File->move: absolute:[TEST_PATH]/backrest/archive/db/out/000000010000000100000005.tmp to absolute:[TEST_PATH]/backrest/archive/db/out/000000010000000100000005-4518a0fdf41d796760b384a358270d4682589820, destination_path_create = true
+  INFO: No fork on archive local for TESTING
+  INFO: starting async archive-push
+ DEBUG:     File->manifest: db:absolute:[TEST_PATH]/backrest/archive/db/out
+  INFO: archive to be copied to backup total 1, size 16MB
+ DEBUG:     archive 000000010000000100000005-4518a0fdf41d796760b384a358270d4682589820, is WAL 1, source_compressed = 0, destination_compress 0, default_compress = 0
+ DEBUG:     Archive->pushCheck: backup:archive:000000010000000100000005
+ DEBUG:     File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
+ DEBUG:     File->exists: backup:archive:[TEST_PATH]/backrest/archive/db/archive.info
+ DEBUG:     File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/0000000100000001, expression ^000000010000000100000005(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
+ DEBUG:     File->hash: db:absolute:[TEST_PATH]/backrest/archive/db/out/000000010000000100000005-4518a0fdf41d796760b384a358270d4682589820, compressed = false, hash_type = sha1
  ERROR: [120]: WAL segment 000000010000000100000005 already exists in the archive
  DEBUG:     safe exit called, terminating threads
 
@@ -348,5 +398,30 @@ run 002 - rmt 0, cmp 0, arc_async 1
  DEBUG:     File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
  DEBUG:     File->exists: backup:archive:[TEST_PATH]/backrest/archive/db/archive.info
  DEBUG:     File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/0000000100000001, expression ^000000010000000100000009(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
+ DEBUG:     File->hash: db:absolute:[TEST_PATH]/backrest/archive/db/out/000000010000000100000009-1c7e00fd09b9dd11fc2966590b3e3274645dd031, compressed = false, hash_type = sha1
+  WARN: WAL segment 000000010000000100000009 already exists in the archive with the same checksum - this is valid in some recovery scenarios but may also indicate a problem
+ DEBUG:     File->copy:  local db:absolute:[TEST_PATH]/backrest/archive/db/out/000000010000000100000009-1c7e00fd09b9dd11fc2966590b3e3274645dd031 to local backup:archive:[TEST_PATH]/backrest/archive/db/0000000100000001/000000010000000100000009-1c7e00fd09b9dd11fc2966590b3e3274645dd031, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = [undef], user = [undef], group = [undef]
+ DEBUG:     File->move: absolute:[TEST_PATH]/backrest/archive/db/0000000100000001/000000010000000100000009-1c7e00fd09b9dd11fc2966590b3e3274645dd031.tmp to absolute:[TEST_PATH]/backrest/archive/db/0000000100000001/000000010000000100000009-1c7e00fd09b9dd11fc2966590b3e3274645dd031, destination_path_create = true
+ DEBUG:     1 WAL segments were transferred, calling Archive->xfer() again
+ DEBUG:     File->manifest: db:absolute:[TEST_PATH]/backrest/archive/db/out
+ DEBUG:     no archive logs to be copied to backup
+ DEBUG:     no more WAL segments to transfer - exiting
+ DEBUG:     safe exit called, terminating threads
+
+> ../bin/pg_backrest.pl --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
+------------------------------------------------------------------------------------------------------------------------------------
+  INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000009 asynchronously
+ DEBUG:     File->copy:  local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000009 to local backup:archive:out:[TEST_PATH]/backrest/archive/db/out/000000010000000100000009, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = [undef], user = [undef], group = [undef]
+ DEBUG:     File->move: absolute:[TEST_PATH]/backrest/archive/db/out/000000010000000100000009.tmp to absolute:[TEST_PATH]/backrest/archive/db/out/000000010000000100000009-4518a0fdf41d796760b384a358270d4682589820, destination_path_create = true
+  INFO: No fork on archive local for TESTING
+  INFO: starting async archive-push
+ DEBUG:     File->manifest: db:absolute:[TEST_PATH]/backrest/archive/db/out
+  INFO: archive to be copied to backup total 1, size 16MB
+ DEBUG:     archive 000000010000000100000009-4518a0fdf41d796760b384a358270d4682589820, is WAL 1, source_compressed = 0, destination_compress 0, default_compress = 0
+ DEBUG:     Archive->pushCheck: backup:archive:000000010000000100000009
+ DEBUG:     File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
+ DEBUG:     File->exists: backup:archive:[TEST_PATH]/backrest/archive/db/archive.info
+ DEBUG:     File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/0000000100000001, expression ^000000010000000100000009(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
+ DEBUG:     File->hash: db:absolute:[TEST_PATH]/backrest/archive/db/out/000000010000000100000009-4518a0fdf41d796760b384a358270d4682589820, compressed = false, hash_type = sha1
  ERROR: [120]: WAL segment 000000010000000100000009 already exists in the archive
  DEBUG:     safe exit called, terminating threads
diff --git a/test/log/backup-archive-push-003.log b/test/log/backup-archive-push-003.log
index 617eb6115..571ccce5b 100644
--- a/test/log/backup-archive-push-003.log
+++ b/test/log/backup-archive-push-003.log
@@ -41,6 +41,20 @@ run 003 - rmt 0, cmp 1, arc_async 0
  DEBUG:     File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
  DEBUG:     File->exists: backup:archive:[TEST_PATH]/backrest/archive/db/archive.info
  DEBUG:     File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/0000000100000001, expression ^000000010000000100000001(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
+ DEBUG:     File->hash: db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000001, compressed = false, hash_type = sha1
+  WARN: WAL segment 000000010000000100000001 already exists in the archive with the same checksum - this is valid in some recovery scenarios but may also indicate a problem
+ DEBUG:     File->copy:  local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000001 to local backup:archive:[TEST_PATH]/backrest/archive/db/0000000100000001/000000010000000100000001.gz, source_compressed = false, destination_compress = true, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = [undef], user = [undef], group = [undef]
+ DEBUG:     File->move: absolute:[TEST_PATH]/backrest/archive/db/0000000100000001/000000010000000100000001.gz.tmp to absolute:[TEST_PATH]/backrest/archive/db/0000000100000001/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz, destination_path_create = true
+ DEBUG:     safe exit called, terminating threads
+
+> ../bin/pg_backrest.pl --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
+------------------------------------------------------------------------------------------------------------------------------------
+  INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
+ DEBUG:     Archive->pushCheck: backup:archive:000000010000000100000001
+ DEBUG:     File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
+ DEBUG:     File->exists: backup:archive:[TEST_PATH]/backrest/archive/db/archive.info
+ DEBUG:     File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/0000000100000001, expression ^000000010000000100000001(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
+ DEBUG:     File->hash: db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000001, compressed = false, hash_type = sha1
  ERROR: [120]: WAL segment 000000010000000100000001 already exists in the archive
  DEBUG:     safe exit called, terminating threads
 
@@ -113,6 +127,20 @@ run 003 - rmt 0, cmp 1, arc_async 0
  DEBUG:     File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
  DEBUG:     File->exists: backup:archive:[TEST_PATH]/backrest/archive/db/archive.info
  DEBUG:     File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/0000000100000001, expression ^000000010000000100000005(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
+ DEBUG:     File->hash: db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000005, compressed = false, hash_type = sha1
+  WARN: WAL segment 000000010000000100000005 already exists in the archive with the same checksum - this is valid in some recovery scenarios but may also indicate a problem
+ DEBUG:     File->copy:  local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000005 to local backup:archive:[TEST_PATH]/backrest/archive/db/0000000100000001/000000010000000100000005.gz, source_compressed = false, destination_compress = true, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = [undef], user = [undef], group = [undef]
+ DEBUG:     File->move: absolute:[TEST_PATH]/backrest/archive/db/0000000100000001/000000010000000100000005.gz.tmp to absolute:[TEST_PATH]/backrest/archive/db/0000000100000001/000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz, destination_path_create = true
+ DEBUG:     safe exit called, terminating threads
+
+> ../bin/pg_backrest.pl --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
+------------------------------------------------------------------------------------------------------------------------------------
+  INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
+ DEBUG:     Archive->pushCheck: backup:archive:000000010000000100000005
+ DEBUG:     File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
+ DEBUG:     File->exists: backup:archive:[TEST_PATH]/backrest/archive/db/archive.info
+ DEBUG:     File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/0000000100000001, expression ^000000010000000100000005(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
+ DEBUG:     File->hash: db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000005, compressed = false, hash_type = sha1
  ERROR: [120]: WAL segment 000000010000000100000005 already exists in the archive
  DEBUG:     safe exit called, terminating threads
 
@@ -185,5 +213,19 @@ run 003 - rmt 0, cmp 1, arc_async 0
  DEBUG:     File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
  DEBUG:     File->exists: backup:archive:[TEST_PATH]/backrest/archive/db/archive.info
  DEBUG:     File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/0000000100000001, expression ^000000010000000100000009(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
+ DEBUG:     File->hash: db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000009, compressed = false, hash_type = sha1
+  WARN: WAL segment 000000010000000100000009 already exists in the archive with the same checksum - this is valid in some recovery scenarios but may also indicate a problem
+ DEBUG:     File->copy:  local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000009 to local backup:archive:[TEST_PATH]/backrest/archive/db/0000000100000001/000000010000000100000009.gz, source_compressed = false, destination_compress = true, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = [undef], user = [undef], group = [undef]
+ DEBUG:     File->move: absolute:[TEST_PATH]/backrest/archive/db/0000000100000001/000000010000000100000009.gz.tmp to absolute:[TEST_PATH]/backrest/archive/db/0000000100000001/000000010000000100000009-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz, destination_path_create = true
+ DEBUG:     safe exit called, terminating threads
+
+> ../bin/pg_backrest.pl --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
+------------------------------------------------------------------------------------------------------------------------------------
+  INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
+ DEBUG:     Archive->pushCheck: backup:archive:000000010000000100000009
+ DEBUG:     File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
+ DEBUG:     File->exists: backup:archive:[TEST_PATH]/backrest/archive/db/archive.info
+ DEBUG:     File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/0000000100000001, expression ^000000010000000100000009(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
+ DEBUG:     File->hash: db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000009, compressed = false, hash_type = sha1
  ERROR: [120]: WAL segment 000000010000000100000009 already exists in the archive
  DEBUG:     safe exit called, terminating threads
diff --git a/test/log/backup-archive-push-004.log b/test/log/backup-archive-push-004.log
index 75aec8799..b2b23b8e6 100644
--- a/test/log/backup-archive-push-004.log
+++ b/test/log/backup-archive-push-004.log
@@ -74,6 +74,31 @@ run 004 - rmt 0, cmp 1, arc_async 1
  DEBUG:     File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
  DEBUG:     File->exists: backup:archive:[TEST_PATH]/backrest/archive/db/archive.info
  DEBUG:     File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/0000000100000001, expression ^000000010000000100000001(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
+ DEBUG:     File->hash: db:absolute:[TEST_PATH]/backrest/archive/db/out/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031, compressed = false, hash_type = sha1
+  WARN: WAL segment 000000010000000100000001 already exists in the archive with the same checksum - this is valid in some recovery scenarios but may also indicate a problem
+ DEBUG:     File->copy:  local db:absolute:[TEST_PATH]/backrest/archive/db/out/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031 to local backup:archive:[TEST_PATH]/backrest/archive/db/0000000100000001/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz, source_compressed = false, destination_compress = true, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = [undef], user = [undef], group = [undef]
+ DEBUG:     File->move: absolute:[TEST_PATH]/backrest/archive/db/0000000100000001/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz.tmp to absolute:[TEST_PATH]/backrest/archive/db/0000000100000001/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz, destination_path_create = true
+ DEBUG:     1 WAL segments were transferred, calling Archive->xfer() again
+ DEBUG:     File->manifest: db:absolute:[TEST_PATH]/backrest/archive/db/out
+ DEBUG:     no archive logs to be copied to backup
+ DEBUG:     no more WAL segments to transfer - exiting
+ DEBUG:     safe exit called, terminating threads
+
+> ../bin/pg_backrest.pl --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
+------------------------------------------------------------------------------------------------------------------------------------
+  INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000001 asynchronously
+ DEBUG:     File->copy:  local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000001 to local backup:archive:out:[TEST_PATH]/backrest/archive/db/out/000000010000000100000001, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = [undef], user = [undef], group = [undef]
+ DEBUG:     File->move: absolute:[TEST_PATH]/backrest/archive/db/out/000000010000000100000001.tmp to absolute:[TEST_PATH]/backrest/archive/db/out/000000010000000100000001-4518a0fdf41d796760b384a358270d4682589820, destination_path_create = true
+  INFO: No fork on archive local for TESTING
+  INFO: starting async archive-push
+ DEBUG:     File->manifest: db:absolute:[TEST_PATH]/backrest/archive/db/out
+  INFO: archive to be copied to backup total 1, size 16MB
+ DEBUG:     archive 000000010000000100000001-4518a0fdf41d796760b384a358270d4682589820, is WAL 1, source_compressed = 0, destination_compress 1, default_compress = 1
+ DEBUG:     Archive->pushCheck: backup:archive:000000010000000100000001
+ DEBUG:     File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
+ DEBUG:     File->exists: backup:archive:[TEST_PATH]/backrest/archive/db/archive.info
+ DEBUG:     File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/0000000100000001, expression ^000000010000000100000001(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
+ DEBUG:     File->hash: db:absolute:[TEST_PATH]/backrest/archive/db/out/000000010000000100000001-4518a0fdf41d796760b384a358270d4682589820, compressed = false, hash_type = sha1
  ERROR: [120]: WAL segment 000000010000000100000001 already exists in the archive
  DEBUG:     safe exit called, terminating threads
 
@@ -211,6 +236,31 @@ run 004 - rmt 0, cmp 1, arc_async 1
  DEBUG:     File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
  DEBUG:     File->exists: backup:archive:[TEST_PATH]/backrest/archive/db/archive.info
  DEBUG:     File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/0000000100000001, expression ^000000010000000100000005(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
+ DEBUG:     File->hash: db:absolute:[TEST_PATH]/backrest/archive/db/out/000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031, compressed = false, hash_type = sha1
+  WARN: WAL segment 000000010000000100000005 already exists in the archive with the same checksum - this is valid in some recovery scenarios but may also indicate a problem
+ DEBUG:     File->copy:  local db:absolute:[TEST_PATH]/backrest/archive/db/out/000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031 to local backup:archive:[TEST_PATH]/backrest/archive/db/0000000100000001/000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz, source_compressed = false, destination_compress = true, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = [undef], user = [undef], group = [undef]
+ DEBUG:     File->move: absolute:[TEST_PATH]/backrest/archive/db/0000000100000001/000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz.tmp to absolute:[TEST_PATH]/backrest/archive/db/0000000100000001/000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz, destination_path_create = true
+ DEBUG:     1 WAL segments were transferred, calling Archive->xfer() again
+ DEBUG:     File->manifest: db:absolute:[TEST_PATH]/backrest/archive/db/out
+ DEBUG:     no archive logs to be copied to backup
+ DEBUG:     no more WAL segments to transfer - exiting
+ DEBUG:     safe exit called, terminating threads
+
+> ../bin/pg_backrest.pl --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
+------------------------------------------------------------------------------------------------------------------------------------
+  INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000005 asynchronously
+ DEBUG:     File->copy:  local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000005 to local backup:archive:out:[TEST_PATH]/backrest/archive/db/out/000000010000000100000005, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = [undef], user = [undef], group = [undef]
+ DEBUG:     File->move: absolute:[TEST_PATH]/backrest/archive/db/out/000000010000000100000005.tmp to absolute:[TEST_PATH]/backrest/archive/db/out/000000010000000100000005-4518a0fdf41d796760b384a358270d4682589820, destination_path_create = true
+  INFO: No fork on archive local for TESTING
+  INFO: starting async archive-push
+ DEBUG:     File->manifest: db:absolute:[TEST_PATH]/backrest/archive/db/out
+  INFO: archive to be copied to backup total 1, size 16MB
+ DEBUG:     archive 000000010000000100000005-4518a0fdf41d796760b384a358270d4682589820, is WAL 1, source_compressed = 0, destination_compress 1, default_compress = 1
+ DEBUG:     Archive->pushCheck: backup:archive:000000010000000100000005
+ DEBUG:     File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
+ DEBUG:     File->exists: backup:archive:[TEST_PATH]/backrest/archive/db/archive.info
+ DEBUG:     File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/0000000100000001, expression ^000000010000000100000005(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
+ DEBUG:     File->hash: db:absolute:[TEST_PATH]/backrest/archive/db/out/000000010000000100000005-4518a0fdf41d796760b384a358270d4682589820, compressed = false, hash_type = sha1
  ERROR: [120]: WAL segment 000000010000000100000005 already exists in the archive
  DEBUG:     safe exit called, terminating threads
 
@@ -348,5 +398,30 @@ run 004 - rmt 0, cmp 1, arc_async 1
  DEBUG:     File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
  DEBUG:     File->exists: backup:archive:[TEST_PATH]/backrest/archive/db/archive.info
  DEBUG:     File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/0000000100000001, expression ^000000010000000100000009(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
+ DEBUG:     File->hash: db:absolute:[TEST_PATH]/backrest/archive/db/out/000000010000000100000009-1c7e00fd09b9dd11fc2966590b3e3274645dd031, compressed = false, hash_type = sha1
+  WARN: WAL segment 000000010000000100000009 already exists in the archive with the same checksum - this is valid in some recovery scenarios but may also indicate a problem
+ DEBUG:     File->copy:  local db:absolute:[TEST_PATH]/backrest/archive/db/out/000000010000000100000009-1c7e00fd09b9dd11fc2966590b3e3274645dd031 to local backup:archive:[TEST_PATH]/backrest/archive/db/0000000100000001/000000010000000100000009-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz, source_compressed = false, destination_compress = true, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = [undef], user = [undef], group = [undef]
+ DEBUG:     File->move: absolute:[TEST_PATH]/backrest/archive/db/0000000100000001/000000010000000100000009-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz.tmp to absolute:[TEST_PATH]/backrest/archive/db/0000000100000001/000000010000000100000009-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz, destination_path_create = true
+ DEBUG:     1 WAL segments were transferred, calling Archive->xfer() again
+ DEBUG:     File->manifest: db:absolute:[TEST_PATH]/backrest/archive/db/out
+ DEBUG:     no archive logs to be copied to backup
+ DEBUG:     no more WAL segments to transfer - exiting
+ DEBUG:     safe exit called, terminating threads
+
+> ../bin/pg_backrest.pl --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
+------------------------------------------------------------------------------------------------------------------------------------
+  INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000009 asynchronously
+ DEBUG:     File->copy:  local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000009 to local backup:archive:out:[TEST_PATH]/backrest/archive/db/out/000000010000000100000009, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = [undef], user = [undef], group = [undef]
+ DEBUG:     File->move: absolute:[TEST_PATH]/backrest/archive/db/out/000000010000000100000009.tmp to absolute:[TEST_PATH]/backrest/archive/db/out/000000010000000100000009-4518a0fdf41d796760b384a358270d4682589820, destination_path_create = true
+  INFO: No fork on archive local for TESTING
+  INFO: starting async archive-push
+ DEBUG:     File->manifest: db:absolute:[TEST_PATH]/backrest/archive/db/out
+  INFO: archive to be copied to backup total 1, size 16MB
+ DEBUG:     archive 000000010000000100000009-4518a0fdf41d796760b384a358270d4682589820, is WAL 1, source_compressed = 0, destination_compress 1, default_compress = 1
+ DEBUG:     Archive->pushCheck: backup:archive:000000010000000100000009
+ DEBUG:     File->exists: backup:archive:[TEST_PATH]/backrest/archive/db
+ DEBUG:     File->exists: backup:archive:[TEST_PATH]/backrest/archive/db/archive.info
+ DEBUG:     File->list: backup:absolute:[TEST_PATH]/backrest/archive/db/0000000100000001, expression ^000000010000000100000009(-[0-f]+){0,1}(\.gz){0,1}$, sort forward
+ DEBUG:     File->hash: db:absolute:[TEST_PATH]/backrest/archive/db/out/000000010000000100000009-4518a0fdf41d796760b384a358270d4682589820, compressed = false, hash_type = sha1
  ERROR: [120]: WAL segment 000000010000000100000009 already exists in the archive
  DEBUG:     safe exit called, terminating threads
diff --git a/test/log/backup-archive-push-005.log b/test/log/backup-archive-push-005.log
index effb4e0cd..7207bffa5 100644
--- a/test/log/backup-archive-push-005.log
+++ b/test/log/backup-archive-push-005.log
@@ -26,7 +26,17 @@ run 005 - rmt 1, cmp 0, arc_async 0
 ------------------------------------------------------------------------------------------------------------------------------------
   INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
  DEBUG:     Archive->pushCheck: backup:archive:000000010000000100000001
- ERROR: [120]: : WAL segment 000000010000000100000001 already exists in the archive
+ DEBUG:     File->hash: db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000001, compressed = false, hash_type = sha1
+  WARN: WAL segment 000000010000000100000001 already exists in the archive with the same checksum - this is valid in some recovery scenarios but may also indicate a problem
+ DEBUG:     File->copy:  local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000001 to remote backup:archive:[TEST_PATH]/backrest/archive/db/0000000100000001/000000010000000100000001, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = [undef], user = [undef], group = [undef]
+ DEBUG:     safe exit called, terminating threads
+
+> ../bin/pg_backrest.pl --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
+------------------------------------------------------------------------------------------------------------------------------------
+  INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
+ DEBUG:     Archive->pushCheck: backup:archive:000000010000000100000001
+ DEBUG:     File->hash: db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000001, compressed = false, hash_type = sha1
+ ERROR: [120]: WAL segment 000000010000000100000001 already exists in the archive
  DEBUG:     safe exit called, terminating threads
 
 > ../bin/pg_backrest.pl --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000002
@@ -75,7 +85,17 @@ run 005 - rmt 1, cmp 0, arc_async 0
 ------------------------------------------------------------------------------------------------------------------------------------
   INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
  DEBUG:     Archive->pushCheck: backup:archive:000000010000000100000005
- ERROR: [120]: : WAL segment 000000010000000100000005 already exists in the archive
+ DEBUG:     File->hash: db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000005, compressed = false, hash_type = sha1
+  WARN: WAL segment 000000010000000100000005 already exists in the archive with the same checksum - this is valid in some recovery scenarios but may also indicate a problem
+ DEBUG:     File->copy:  local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000005 to remote backup:archive:[TEST_PATH]/backrest/archive/db/0000000100000001/000000010000000100000005, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = [undef], user = [undef], group = [undef]
+ DEBUG:     safe exit called, terminating threads
+
+> ../bin/pg_backrest.pl --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
+------------------------------------------------------------------------------------------------------------------------------------
+  INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
+ DEBUG:     Archive->pushCheck: backup:archive:000000010000000100000005
+ DEBUG:     File->hash: db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000005, compressed = false, hash_type = sha1
+ ERROR: [120]: WAL segment 000000010000000100000005 already exists in the archive
  DEBUG:     safe exit called, terminating threads
 
 > ../bin/pg_backrest.pl --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000006
@@ -124,5 +144,15 @@ run 005 - rmt 1, cmp 0, arc_async 0
 ------------------------------------------------------------------------------------------------------------------------------------
   INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
  DEBUG:     Archive->pushCheck: backup:archive:000000010000000100000009
- ERROR: [120]: : WAL segment 000000010000000100000009 already exists in the archive
+ DEBUG:     File->hash: db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000009, compressed = false, hash_type = sha1
+  WARN: WAL segment 000000010000000100000009 already exists in the archive with the same checksum - this is valid in some recovery scenarios but may also indicate a problem
+ DEBUG:     File->copy:  local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000009 to remote backup:archive:[TEST_PATH]/backrest/archive/db/0000000100000001/000000010000000100000009, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = [undef], user = [undef], group = [undef]
+ DEBUG:     safe exit called, terminating threads
+
+> ../bin/pg_backrest.pl --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
+------------------------------------------------------------------------------------------------------------------------------------
+  INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
+ DEBUG:     Archive->pushCheck: backup:archive:000000010000000100000009
+ DEBUG:     File->hash: db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000009, compressed = false, hash_type = sha1
+ ERROR: [120]: WAL segment 000000010000000100000009 already exists in the archive
  DEBUG:     safe exit called, terminating threads
diff --git a/test/log/backup-archive-push-006.log b/test/log/backup-archive-push-006.log
index 312bb8ea8..185c4bc6a 100644
--- a/test/log/backup-archive-push-006.log
+++ b/test/log/backup-archive-push-006.log
@@ -60,7 +60,28 @@ run 006 - rmt 1, cmp 0, arc_async 1
   INFO: archive to be copied to backup total 1, size 16MB
  DEBUG:     archive 000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031, is WAL 1, source_compressed = 0, destination_compress 0, default_compress = 0
  DEBUG:     Archive->pushCheck: backup:archive:000000010000000100000001
- ERROR: [120]: : WAL segment 000000010000000100000001 already exists in the archive
+ DEBUG:     File->hash: db:absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031, compressed = false, hash_type = sha1
+  WARN: WAL segment 000000010000000100000001 already exists in the archive with the same checksum - this is valid in some recovery scenarios but may also indicate a problem
+ DEBUG:     File->copy:  local db:absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031 to remote backup:archive:[TEST_PATH]/backrest/archive/db/0000000100000001/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = [undef], user = [undef], group = [undef]
+ DEBUG:     1 WAL segments were transferred, calling Archive->xfer() again
+ DEBUG:     File->manifest: db:absolute:[TEST_PATH]/local/archive/db/out
+ DEBUG:     no archive logs to be copied to backup
+ DEBUG:     no more WAL segments to transfer - exiting
+ DEBUG:     safe exit called, terminating threads
+
+> ../bin/pg_backrest.pl --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
+------------------------------------------------------------------------------------------------------------------------------------
+  INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000001 asynchronously
+ DEBUG:     File->copy:  local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000001 to local backup:archive:out:[TEST_PATH]/local/archive/db/out/000000010000000100000001, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = [undef], user = [undef], group = [undef]
+ DEBUG:     File->move: absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000001.tmp to absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000001-4518a0fdf41d796760b384a358270d4682589820, destination_path_create = true
+  INFO: No fork on archive local for TESTING
+  INFO: starting async archive-push
+ DEBUG:     File->manifest: db:absolute:[TEST_PATH]/local/archive/db/out
+  INFO: archive to be copied to backup total 1, size 16MB
+ DEBUG:     archive 000000010000000100000001-4518a0fdf41d796760b384a358270d4682589820, is WAL 1, source_compressed = 0, destination_compress 0, default_compress = 0
+ DEBUG:     Archive->pushCheck: backup:archive:000000010000000100000001
+ DEBUG:     File->hash: db:absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000001-4518a0fdf41d796760b384a358270d4682589820, compressed = false, hash_type = sha1
+ ERROR: [120]: WAL segment 000000010000000100000001 already exists in the archive
  DEBUG:     safe exit called, terminating threads
 
 > ../bin/pg_backrest.pl --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000002
@@ -174,7 +195,28 @@ run 006 - rmt 1, cmp 0, arc_async 1
   INFO: archive to be copied to backup total 1, size 16MB
  DEBUG:     archive 000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031, is WAL 1, source_compressed = 0, destination_compress 0, default_compress = 0
  DEBUG:     Archive->pushCheck: backup:archive:000000010000000100000005
- ERROR: [120]: : WAL segment 000000010000000100000005 already exists in the archive
+ DEBUG:     File->hash: db:absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031, compressed = false, hash_type = sha1
+  WARN: WAL segment 000000010000000100000005 already exists in the archive with the same checksum - this is valid in some recovery scenarios but may also indicate a problem
+ DEBUG:     File->copy:  local db:absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031 to remote backup:archive:[TEST_PATH]/backrest/archive/db/0000000100000001/000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = [undef], user = [undef], group = [undef]
+ DEBUG:     1 WAL segments were transferred, calling Archive->xfer() again
+ DEBUG:     File->manifest: db:absolute:[TEST_PATH]/local/archive/db/out
+ DEBUG:     no archive logs to be copied to backup
+ DEBUG:     no more WAL segments to transfer - exiting
+ DEBUG:     safe exit called, terminating threads
+
+> ../bin/pg_backrest.pl --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
+------------------------------------------------------------------------------------------------------------------------------------
+  INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000005 asynchronously
+ DEBUG:     File->copy:  local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000005 to local backup:archive:out:[TEST_PATH]/local/archive/db/out/000000010000000100000005, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = [undef], user = [undef], group = [undef]
+ DEBUG:     File->move: absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000005.tmp to absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000005-4518a0fdf41d796760b384a358270d4682589820, destination_path_create = true
+  INFO: No fork on archive local for TESTING
+  INFO: starting async archive-push
+ DEBUG:     File->manifest: db:absolute:[TEST_PATH]/local/archive/db/out
+  INFO: archive to be copied to backup total 1, size 16MB
+ DEBUG:     archive 000000010000000100000005-4518a0fdf41d796760b384a358270d4682589820, is WAL 1, source_compressed = 0, destination_compress 0, default_compress = 0
+ DEBUG:     Archive->pushCheck: backup:archive:000000010000000100000005
+ DEBUG:     File->hash: db:absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000005-4518a0fdf41d796760b384a358270d4682589820, compressed = false, hash_type = sha1
+ ERROR: [120]: WAL segment 000000010000000100000005 already exists in the archive
  DEBUG:     safe exit called, terminating threads
 
 > ../bin/pg_backrest.pl --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000006
@@ -288,5 +330,26 @@ run 006 - rmt 1, cmp 0, arc_async 1
   INFO: archive to be copied to backup total 1, size 16MB
  DEBUG:     archive 000000010000000100000009-1c7e00fd09b9dd11fc2966590b3e3274645dd031, is WAL 1, source_compressed = 0, destination_compress 0, default_compress = 0
  DEBUG:     Archive->pushCheck: backup:archive:000000010000000100000009
- ERROR: [120]: : WAL segment 000000010000000100000009 already exists in the archive
+ DEBUG:     File->hash: db:absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000009-1c7e00fd09b9dd11fc2966590b3e3274645dd031, compressed = false, hash_type = sha1
+  WARN: WAL segment 000000010000000100000009 already exists in the archive with the same checksum - this is valid in some recovery scenarios but may also indicate a problem
+ DEBUG:     File->copy:  local db:absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000009-1c7e00fd09b9dd11fc2966590b3e3274645dd031 to remote backup:archive:[TEST_PATH]/backrest/archive/db/0000000100000001/000000010000000100000009-1c7e00fd09b9dd11fc2966590b3e3274645dd031, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = [undef], user = [undef], group = [undef]
+ DEBUG:     1 WAL segments were transferred, calling Archive->xfer() again
+ DEBUG:     File->manifest: db:absolute:[TEST_PATH]/local/archive/db/out
+ DEBUG:     no archive logs to be copied to backup
+ DEBUG:     no more WAL segments to transfer - exiting
+ DEBUG:     safe exit called, terminating threads
+
+> ../bin/pg_backrest.pl --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
+------------------------------------------------------------------------------------------------------------------------------------
+  INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000009 asynchronously
+ DEBUG:     File->copy:  local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000009 to local backup:archive:out:[TEST_PATH]/local/archive/db/out/000000010000000100000009, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = [undef], user = [undef], group = [undef]
+ DEBUG:     File->move: absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000009.tmp to absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000009-4518a0fdf41d796760b384a358270d4682589820, destination_path_create = true
+  INFO: No fork on archive local for TESTING
+  INFO: starting async archive-push
+ DEBUG:     File->manifest: db:absolute:[TEST_PATH]/local/archive/db/out
+  INFO: archive to be copied to backup total 1, size 16MB
+ DEBUG:     archive 000000010000000100000009-4518a0fdf41d796760b384a358270d4682589820, is WAL 1, source_compressed = 0, destination_compress 0, default_compress = 0
+ DEBUG:     Archive->pushCheck: backup:archive:000000010000000100000009
+ DEBUG:     File->hash: db:absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000009-4518a0fdf41d796760b384a358270d4682589820, compressed = false, hash_type = sha1
+ ERROR: [120]: WAL segment 000000010000000100000009 already exists in the archive
  DEBUG:     safe exit called, terminating threads
diff --git a/test/log/backup-archive-push-007.log b/test/log/backup-archive-push-007.log
index 57001d70f..711e23a39 100644
--- a/test/log/backup-archive-push-007.log
+++ b/test/log/backup-archive-push-007.log
@@ -26,7 +26,17 @@ run 007 - rmt 1, cmp 1, arc_async 0
 ------------------------------------------------------------------------------------------------------------------------------------
   INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
  DEBUG:     Archive->pushCheck: backup:archive:000000010000000100000001
- ERROR: [120]: : WAL segment 000000010000000100000001 already exists in the archive
+ DEBUG:     File->hash: db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000001, compressed = false, hash_type = sha1
+  WARN: WAL segment 000000010000000100000001 already exists in the archive with the same checksum - this is valid in some recovery scenarios but may also indicate a problem
+ DEBUG:     File->copy:  local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000001 to remote backup:archive:[TEST_PATH]/backrest/archive/db/0000000100000001/000000010000000100000001.gz, source_compressed = false, destination_compress = true, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = [undef], user = [undef], group = [undef]
+ DEBUG:     safe exit called, terminating threads
+
+> ../bin/pg_backrest.pl --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
+------------------------------------------------------------------------------------------------------------------------------------
+  INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
+ DEBUG:     Archive->pushCheck: backup:archive:000000010000000100000001
+ DEBUG:     File->hash: db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000001, compressed = false, hash_type = sha1
+ ERROR: [120]: WAL segment 000000010000000100000001 already exists in the archive
  DEBUG:     safe exit called, terminating threads
 
 > ../bin/pg_backrest.pl --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000002
@@ -75,7 +85,17 @@ run 007 - rmt 1, cmp 1, arc_async 0
 ------------------------------------------------------------------------------------------------------------------------------------
   INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
  DEBUG:     Archive->pushCheck: backup:archive:000000010000000100000005
- ERROR: [120]: : WAL segment 000000010000000100000005 already exists in the archive
+ DEBUG:     File->hash: db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000005, compressed = false, hash_type = sha1
+  WARN: WAL segment 000000010000000100000005 already exists in the archive with the same checksum - this is valid in some recovery scenarios but may also indicate a problem
+ DEBUG:     File->copy:  local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000005 to remote backup:archive:[TEST_PATH]/backrest/archive/db/0000000100000001/000000010000000100000005.gz, source_compressed = false, destination_compress = true, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = [undef], user = [undef], group = [undef]
+ DEBUG:     safe exit called, terminating threads
+
+> ../bin/pg_backrest.pl --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
+------------------------------------------------------------------------------------------------------------------------------------
+  INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
+ DEBUG:     Archive->pushCheck: backup:archive:000000010000000100000005
+ DEBUG:     File->hash: db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000005, compressed = false, hash_type = sha1
+ ERROR: [120]: WAL segment 000000010000000100000005 already exists in the archive
  DEBUG:     safe exit called, terminating threads
 
 > ../bin/pg_backrest.pl --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000006
@@ -124,5 +144,15 @@ run 007 - rmt 1, cmp 1, arc_async 0
 ------------------------------------------------------------------------------------------------------------------------------------
   INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
  DEBUG:     Archive->pushCheck: backup:archive:000000010000000100000009
- ERROR: [120]: : WAL segment 000000010000000100000009 already exists in the archive
+ DEBUG:     File->hash: db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000009, compressed = false, hash_type = sha1
+  WARN: WAL segment 000000010000000100000009 already exists in the archive with the same checksum - this is valid in some recovery scenarios but may also indicate a problem
+ DEBUG:     File->copy:  local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000009 to remote backup:archive:[TEST_PATH]/backrest/archive/db/0000000100000001/000000010000000100000009.gz, source_compressed = false, destination_compress = true, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = [undef], user = [undef], group = [undef]
+ DEBUG:     safe exit called, terminating threads
+
+> ../bin/pg_backrest.pl --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
+------------------------------------------------------------------------------------------------------------------------------------
+  INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
+ DEBUG:     Archive->pushCheck: backup:archive:000000010000000100000009
+ DEBUG:     File->hash: db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000009, compressed = false, hash_type = sha1
+ ERROR: [120]: WAL segment 000000010000000100000009 already exists in the archive
  DEBUG:     safe exit called, terminating threads
diff --git a/test/log/backup-archive-push-008.log b/test/log/backup-archive-push-008.log
index f5d46cd46..1835f7f01 100644
--- a/test/log/backup-archive-push-008.log
+++ b/test/log/backup-archive-push-008.log
@@ -60,7 +60,28 @@ run 008 - rmt 1, cmp 1, arc_async 1
   INFO: archive to be copied to backup total 1, size 16MB
  DEBUG:     archive 000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031, is WAL 1, source_compressed = 0, destination_compress 1, default_compress = 1
  DEBUG:     Archive->pushCheck: backup:archive:000000010000000100000001
- ERROR: [120]: : WAL segment 000000010000000100000001 already exists in the archive
+ DEBUG:     File->hash: db:absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031, compressed = false, hash_type = sha1
+  WARN: WAL segment 000000010000000100000001 already exists in the archive with the same checksum - this is valid in some recovery scenarios but may also indicate a problem
+ DEBUG:     File->copy:  local db:absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031 to remote backup:archive:[TEST_PATH]/backrest/archive/db/0000000100000001/000000010000000100000001-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz, source_compressed = false, destination_compress = true, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = [undef], user = [undef], group = [undef]
+ DEBUG:     1 WAL segments were transferred, calling Archive->xfer() again
+ DEBUG:     File->manifest: db:absolute:[TEST_PATH]/local/archive/db/out
+ DEBUG:     no archive logs to be copied to backup
+ DEBUG:     no more WAL segments to transfer - exiting
+ DEBUG:     safe exit called, terminating threads
+
+> ../bin/pg_backrest.pl --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000001
+------------------------------------------------------------------------------------------------------------------------------------
+  INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000001 asynchronously
+ DEBUG:     File->copy:  local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000001 to local backup:archive:out:[TEST_PATH]/local/archive/db/out/000000010000000100000001, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = [undef], user = [undef], group = [undef]
+ DEBUG:     File->move: absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000001.tmp to absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000001-4518a0fdf41d796760b384a358270d4682589820, destination_path_create = true
+  INFO: No fork on archive local for TESTING
+  INFO: starting async archive-push
+ DEBUG:     File->manifest: db:absolute:[TEST_PATH]/local/archive/db/out
+  INFO: archive to be copied to backup total 1, size 16MB
+ DEBUG:     archive 000000010000000100000001-4518a0fdf41d796760b384a358270d4682589820, is WAL 1, source_compressed = 0, destination_compress 1, default_compress = 1
+ DEBUG:     Archive->pushCheck: backup:archive:000000010000000100000001
+ DEBUG:     File->hash: db:absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000001-4518a0fdf41d796760b384a358270d4682589820, compressed = false, hash_type = sha1
+ ERROR: [120]: WAL segment 000000010000000100000001 already exists in the archive
  DEBUG:     safe exit called, terminating threads
 
 > ../bin/pg_backrest.pl --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000002
@@ -174,7 +195,28 @@ run 008 - rmt 1, cmp 1, arc_async 1
   INFO: archive to be copied to backup total 1, size 16MB
  DEBUG:     archive 000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031, is WAL 1, source_compressed = 0, destination_compress 1, default_compress = 1
  DEBUG:     Archive->pushCheck: backup:archive:000000010000000100000005
- ERROR: [120]: : WAL segment 000000010000000100000005 already exists in the archive
+ DEBUG:     File->hash: db:absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031, compressed = false, hash_type = sha1
+  WARN: WAL segment 000000010000000100000005 already exists in the archive with the same checksum - this is valid in some recovery scenarios but may also indicate a problem
+ DEBUG:     File->copy:  local db:absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031 to remote backup:archive:[TEST_PATH]/backrest/archive/db/0000000100000001/000000010000000100000005-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz, source_compressed = false, destination_compress = true, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = [undef], user = [undef], group = [undef]
+ DEBUG:     1 WAL segments were transferred, calling Archive->xfer() again
+ DEBUG:     File->manifest: db:absolute:[TEST_PATH]/local/archive/db/out
+ DEBUG:     no archive logs to be copied to backup
+ DEBUG:     no more WAL segments to transfer - exiting
+ DEBUG:     safe exit called, terminating threads
+
+> ../bin/pg_backrest.pl --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000005
+------------------------------------------------------------------------------------------------------------------------------------
+  INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000005 asynchronously
+ DEBUG:     File->copy:  local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000005 to local backup:archive:out:[TEST_PATH]/local/archive/db/out/000000010000000100000005, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = [undef], user = [undef], group = [undef]
+ DEBUG:     File->move: absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000005.tmp to absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000005-4518a0fdf41d796760b384a358270d4682589820, destination_path_create = true
+  INFO: No fork on archive local for TESTING
+  INFO: starting async archive-push
+ DEBUG:     File->manifest: db:absolute:[TEST_PATH]/local/archive/db/out
+  INFO: archive to be copied to backup total 1, size 16MB
+ DEBUG:     archive 000000010000000100000005-4518a0fdf41d796760b384a358270d4682589820, is WAL 1, source_compressed = 0, destination_compress 1, default_compress = 1
+ DEBUG:     Archive->pushCheck: backup:archive:000000010000000100000005
+ DEBUG:     File->hash: db:absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000005-4518a0fdf41d796760b384a358270d4682589820, compressed = false, hash_type = sha1
+ ERROR: [120]: WAL segment 000000010000000100000005 already exists in the archive
  DEBUG:     safe exit called, terminating threads
 
 > ../bin/pg_backrest.pl --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000006
@@ -288,5 +330,26 @@ run 008 - rmt 1, cmp 1, arc_async 1
   INFO: archive to be copied to backup total 1, size 16MB
  DEBUG:     archive 000000010000000100000009-1c7e00fd09b9dd11fc2966590b3e3274645dd031, is WAL 1, source_compressed = 0, destination_compress 1, default_compress = 1
  DEBUG:     Archive->pushCheck: backup:archive:000000010000000100000009
- ERROR: [120]: : WAL segment 000000010000000100000009 already exists in the archive
+ DEBUG:     File->hash: db:absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000009-1c7e00fd09b9dd11fc2966590b3e3274645dd031, compressed = false, hash_type = sha1
+  WARN: WAL segment 000000010000000100000009 already exists in the archive with the same checksum - this is valid in some recovery scenarios but may also indicate a problem
+ DEBUG:     File->copy:  local db:absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000009-1c7e00fd09b9dd11fc2966590b3e3274645dd031 to remote backup:archive:[TEST_PATH]/backrest/archive/db/0000000100000001/000000010000000100000009-1c7e00fd09b9dd11fc2966590b3e3274645dd031.gz, source_compressed = false, destination_compress = true, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = [undef], user = [undef], group = [undef]
+ DEBUG:     1 WAL segments were transferred, calling Archive->xfer() again
+ DEBUG:     File->manifest: db:absolute:[TEST_PATH]/local/archive/db/out
+ DEBUG:     no archive logs to be copied to backup
+ DEBUG:     no more WAL segments to transfer - exiting
+ DEBUG:     safe exit called, terminating threads
+
+> ../bin/pg_backrest.pl --config=[TEST_PATH]/db/pg_backrest.conf --no-fork --stanza=db archive-push [TEST_PATH]/db/common/pg_xlog/000000010000000100000009
+------------------------------------------------------------------------------------------------------------------------------------
+  INFO: pushing WAL segment [TEST_PATH]/db/common/pg_xlog/000000010000000100000009 asynchronously
+ DEBUG:     File->copy:  local db:absolute:[TEST_PATH]/db/common/pg_xlog/000000010000000100000009 to local backup:archive:out:[TEST_PATH]/local/archive/db/out/000000010000000100000009, source_compressed = false, destination_compress = false, ignore_missing_source = false, destination_path_create = true, modification_time = [undef], mode = [undef], user = [undef], group = [undef]
+ DEBUG:     File->move: absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000009.tmp to absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000009-4518a0fdf41d796760b384a358270d4682589820, destination_path_create = true
+  INFO: No fork on archive local for TESTING
+  INFO: starting async archive-push
+ DEBUG:     File->manifest: db:absolute:[TEST_PATH]/local/archive/db/out
+  INFO: archive to be copied to backup total 1, size 16MB
+ DEBUG:     archive 000000010000000100000009-4518a0fdf41d796760b384a358270d4682589820, is WAL 1, source_compressed = 0, destination_compress 1, default_compress = 1
+ DEBUG:     Archive->pushCheck: backup:archive:000000010000000100000009
+ DEBUG:     File->hash: db:absolute:[TEST_PATH]/local/archive/db/out/000000010000000100000009-4518a0fdf41d796760b384a358270d4682589820, compressed = false, hash_type = sha1
+ ERROR: [120]: WAL segment 000000010000000100000009 already exists in the archive
  DEBUG:     safe exit called, terminating threads