diff --git a/modules/mol/alg/pymod/ligand_scoring.py b/modules/mol/alg/pymod/ligand_scoring.py
index 7302741a4d7f9e423dd5d1ad0d1edb69648535c4..2491a8a5cb0fcb4c873f295c1f6ee6f8489debf9 100644
--- a/modules/mol/alg/pymod/ligand_scoring.py
+++ b/modules/mol/alg/pymod/ligand_scoring.py
@@ -430,21 +430,26 @@ class LigandScorer:
                             str(model_ligand), str(target_ligand)))
                         continue
 
-                    #LogVerbose("Compute RMSD for model ligand %s" % model_ligand)
                     rmsd = SCRMSD(model_ligand, target_ligand,
                                   transformation=binding_site.transform,
                                   substructure_match=self.substructure_match)
-                    rmsd_full_matrix[target_i, model_i] = {
-                        "rmsd": rmsd,
-                        "chain_mapping": binding_site.GetFlatChainMapping(),
-                        "lddt_bs": binding_site.lDDT,
-                        "bb_rmsd": binding_site.bb_rmsd,
-                        "transform": binding_site.transform,
-                        "bs_num_res": len(binding_site.substructure.residues),
-                        "bs_num_overlap_res": len(binding_site.ref_residues),
-                        "target_ligand": target_ligand,
-                        "model_ligand": model_ligand
-                    }
+                    LogDebug("RMSD: %.4f" % rmsd)
+
+                    # Save results?
+                    if not rmsd_full_matrix[target_i, model_i] or \
+                            rmsd_full_matrix[target_i, model_i]["rmsd"] > rmsd:
+                        rmsd_full_matrix[target_i, model_i] = {
+                            "rmsd": rmsd,
+                            "chain_mapping": binding_site.GetFlatChainMapping(),
+                            "lddt_bs": binding_site.lDDT,
+                            "bb_rmsd": binding_site.bb_rmsd,
+                            "transform": binding_site.transform,
+                            "bs_num_res": len(binding_site.substructure.residues),
+                            "bs_num_overlap_res": len(binding_site.ref_residues),
+                            "target_ligand": target_ligand,
+                            "model_ligand": model_ligand
+                        }
+                        LogDebug("Saved RMSD")
 
                     mdl_bs_ent = self._build_binding_site_entity(
                         model_ligand, binding_site.mdl_residues, [])
@@ -459,20 +464,6 @@ class LigandScorer:
                     #     LogWarning("Can't calculate backbone RMSD: %s"
                     #                " - setting to Infinity" % str(err))
                     #     bb_rmsd = float("inf")
-                    lddt_pli_full_matrix[target_i, model_i] = {
-                        "lddt_pli": np.nan,
-                        "lddt_pli_n_contacts": None,
-                        "rmsd": rmsd,
-                        # "symmetry_number": i,
-                        "chain_mapping": binding_site.GetFlatChainMapping(),
-                        "lddt_bs": binding_site.lDDT,
-                        "bb_rmsd": binding_site.bb_rmsd,
-                        "transform": binding_site.transform,
-                        "bs_num_res": len(binding_site.substructure.residues),
-                        "bs_num_overlap_res": len(binding_site.ref_residues),
-                        "target_ligand": target_ligand,
-                        "model_ligand": model_ligand
-                    }
 
                     # Now for each symmetry, loop and rename atoms according
                     # to ref.
@@ -492,15 +483,28 @@ class LigandScorer:
                                 no_intrachain=True,
                                 return_dist_test=True,
                                 check_resnames=self.check_resnames)
+                        LogDebug("lDDT-PLI for symmetry %d: %.4f" % (i, global_lddt))
 
                         # Save results?
-                        best_lddt = lddt_pli_full_matrix[
-                            target_i, model_i]["lddt_pli"]
-                        if global_lddt > best_lddt or np.isnan(best_lddt):
-                            lddt_pli_full_matrix[target_i, model_i].update({
+                        if not lddt_pli_full_matrix[target_i, model_i] or \
+                                global_lddt > lddt_pli_full_matrix[
+                            target_i, model_i]["lddt_pli"] :
+                            lddt_pli_full_matrix[target_i, model_i] = {
                                 "lddt_pli": global_lddt,
                                 "lddt_pli_n_contacts": lddt_tot,
-                            })
+                                "rmsd": rmsd,
+                                # "symmetry_number": i,
+                                "chain_mapping": binding_site.GetFlatChainMapping(),
+                                "lddt_bs": binding_site.lDDT,
+                                "bb_rmsd": binding_site.bb_rmsd,
+                                "transform": binding_site.transform,
+                                "bs_num_res": len(binding_site.substructure.residues),
+                                "bs_num_overlap_res": len(binding_site.ref_residues),
+                                "target_ligand": target_ligand,
+                                "model_ligand": model_ligand
+                            }
+                            LogDebug("Saved lDDT-PLI")
+
         self._rmsd_full_matrix = rmsd_full_matrix
         self._lddt_pli_full_matrix = lddt_pli_full_matrix
 
diff --git a/modules/mol/alg/tests/test_ligand_scoring.py b/modules/mol/alg/tests/test_ligand_scoring.py
index 7586a67fab5f0c0655df0972b1fdc6d62e2e6481..79b80751be3bc3767b8b5901fb3f2b76221af275 100644
--- a/modules/mol/alg/tests/test_ligand_scoring.py
+++ b/modules/mol/alg/tests/test_ligand_scoring.py
@@ -301,37 +301,37 @@ class TestLigandScoring(unittest.TestCase):
         self.assertFalse(expected_keys.symmetric_difference(sc.lddt_pli_details.keys()))
 
         # rmsd
-        self.assertAlmostEqual(sc.rmsd["J"][(1, "\x00")], 3.8498, 3)
-        self.assertAlmostEqual(sc.rmsd["F"][(1, "\x00")], 57.6295, 3)
+        self.assertAlmostEqual(sc.rmsd["J"][(1, "\x00")], 0.8016608357429504, 5)
+        self.assertAlmostEqual(sc.rmsd["F"][(1, "\x00")], 0.9286373257637024, 5)
         # rmsd_details
-        self.assertEqual(sc.rmsd_details["J"][(1, "\x00")]["chain_mapping"], {'A': 'B', 'H': 'C'})
-        self.assertEqual(sc.rmsd_details["J"][(1, "\x00")]["bs_num_res"], 16)
-        self.assertEqual(sc.rmsd_details["J"][(1, "\x00")]["bs_num_overlap_res"], 16)
-        self.assertEqual(sc.rmsd_details["J"][(1, "\x00")]["target_ligand"].qualified_name, 'L.G3D1')
+        self.assertEqual(sc.rmsd_details["J"][(1, "\x00")]["chain_mapping"], {'F': 'D', 'C': 'C'})
+        self.assertEqual(sc.rmsd_details["J"][(1, "\x00")]["bs_num_res"], 15)
+        self.assertEqual(sc.rmsd_details["J"][(1, "\x00")]["bs_num_overlap_res"], 15)
+        self.assertEqual(sc.rmsd_details["J"][(1, "\x00")]["target_ligand"].qualified_name, 'I.G3D1')
         self.assertEqual(sc.rmsd_details["J"][(1, "\x00")]["model_ligand"].qualified_name, 'J.G3D1')
-        self.assertEqual(sc.rmsd_details["F"][(1, "\x00")]["chain_mapping"], {'F': 'B', 'C': 'C'})
+        self.assertEqual(sc.rmsd_details["F"][(1, "\x00")]["chain_mapping"], {'B': 'B', 'G': 'A'})
         self.assertEqual(sc.rmsd_details["F"][(1, "\x00")]["bs_num_res"], 15)
         self.assertEqual(sc.rmsd_details["F"][(1, "\x00")]["bs_num_overlap_res"], 15)
-        self.assertEqual(sc.rmsd_details["F"][(1, "\x00")]["target_ligand"].qualified_name, 'I.G3D1')
+        self.assertEqual(sc.rmsd_details["F"][(1, "\x00")]["target_ligand"].qualified_name, 'K.G3D1')
         self.assertEqual(sc.rmsd_details["F"][(1, "\x00")]["model_ligand"].qualified_name, 'F.G3D1')
 
         # lddt_pli
-        self.assertAlmostEqual(sc.lddt_pli["J"][(1, "\x00")], 0.91194, 5)
-        self.assertAlmostEqual(sc.lddt_pli["F"][(1, "\x00")], 0.0014598, 6)
+        self.assertAlmostEqual(sc.lddt_pli["J"][(1, "\x00")], 0.9127105666156202, 5)
+        self.assertAlmostEqual(sc.lddt_pli["F"][(1, "\x00")], 0.915929203539823, 6)
         # lddt_pli_details
-        self.assertAlmostEqual(sc.lddt_pli_details["J"][(1, "\x00")]["rmsd"], 4.1008, 4)
+        self.assertAlmostEqual(sc.lddt_pli_details["J"][(1, "\x00")]["rmsd"], 0.8016608357429504, 4)
         self.assertEqual(sc.lddt_pli_details["J"][(1, "\x00")]["lddt_pli_n_contacts"], 5224)
-        self.assertEqual(sc.lddt_pli_details["J"][(1, "\x00")]["chain_mapping"], {'F': 'B', 'C': 'C'})
+        self.assertEqual(sc.lddt_pli_details["J"][(1, "\x00")]["chain_mapping"], {'F': 'D', 'C': 'C'})
         self.assertEqual(sc.lddt_pli_details["J"][(1, "\x00")]["bs_num_res"], 15)
         self.assertEqual(sc.lddt_pli_details["J"][(1, "\x00")]["bs_num_overlap_res"], 15)
         self.assertEqual(sc.lddt_pli_details["J"][(1, "\x00")]["target_ligand"].qualified_name, 'I.G3D1')
         self.assertEqual(sc.lddt_pli_details["J"][(1, "\x00")]["model_ligand"].qualified_name, 'J.G3D1')
-        self.assertAlmostEqual(sc.lddt_pli_details["F"][(1, "\x00")]["rmsd"], 57.7868, 4)
-        self.assertEqual(sc.lddt_pli_details["F"][(1, "\x00")]["lddt_pli_n_contacts"], 5480)
-        self.assertEqual(sc.lddt_pli_details["F"][(1, "\x00")]["chain_mapping"], {'E': 'B', 'D': 'C'})
-        self.assertEqual(sc.lddt_pli_details["F"][(1, "\x00")]["bs_num_res"], 16)
-        self.assertEqual(sc.lddt_pli_details["F"][(1, "\x00")]["bs_num_overlap_res"], 16)
-        self.assertEqual(sc.lddt_pli_details["F"][(1, "\x00")]["target_ligand"].qualified_name, 'J.G3D1')
+        self.assertAlmostEqual(sc.lddt_pli_details["F"][(1, "\x00")]["rmsd"], 0.9286373257637024, 4)
+        self.assertEqual(sc.lddt_pli_details["F"][(1, "\x00")]["lddt_pli_n_contacts"], 5424)
+        self.assertEqual(sc.lddt_pli_details["F"][(1, "\x00")]["chain_mapping"], {'B': 'B', 'G': 'A'})
+        self.assertEqual(sc.lddt_pli_details["F"][(1, "\x00")]["bs_num_res"], 15)
+        self.assertEqual(sc.lddt_pli_details["F"][(1, "\x00")]["bs_num_overlap_res"], 15)
+        self.assertEqual(sc.lddt_pli_details["F"][(1, "\x00")]["target_ligand"].qualified_name, 'K.G3D1')
         self.assertEqual(sc.lddt_pli_details["F"][(1, "\x00")]["model_ligand"].qualified_name, 'F.G3D1')