diff --git a/python/lsst/ip/diffim/makeKernel.py b/python/lsst/ip/diffim/makeKernel.py
index b5457b68..46dc47c6 100644
--- a/python/lsst/ip/diffim/makeKernel.py
+++ b/python/lsst/ip/diffim/makeKernel.py
@@ -276,7 +276,7 @@ def getSelectSources(self, exposure, sigma=None, doSmooth=True, idFactory=None):
         return selectSources
 
     def makeCandidateList(self, convolved, reference, kernelSize,
-                          candidateList, preconvolved=False):
+                          candidateList, preconvolved=False, sigma=None):
         """Make a list of acceptable KernelCandidates.
 
         Generate a list of candidate sources for Psf-matching, remove sources
@@ -309,7 +309,7 @@ def makeCandidateList(self, convolved, reference, kernelSize,
             If ``candidateList`` is empty after sub-selection.
         """
         if candidateList is None:
-            candidateList = self.getSelectSources(reference, doSmooth=not preconvolved)
+            candidateList = self.getSelectSources(reference, doSmooth=not preconvolved, sigma=sigma)
             if len(candidateList) < 1:
                 raise RuntimeError("No kernel candidates after detection and measurement.")
 
diff --git a/python/lsst/ip/diffim/subtractImages.py b/python/lsst/ip/diffim/subtractImages.py
index 25b90143..8cf0f76b 100644
--- a/python/lsst/ip/diffim/subtractImages.py
+++ b/python/lsst/ip/diffim/subtractImages.py
@@ -389,29 +389,29 @@ def run(self, template, science, sources, visitSummary=None):
         # 2. RangeError, in case the template coverage is so poor that we end
         #    up near a region with no data.
         try:
-            templatePsfSize = getPsfFwhm(template.psf)
-            sciencePsfSize = getPsfFwhm(science.psf)
+            self.templatePsfSize = getPsfFwhm(template.psf)
+            self.sciencePsfSize = getPsfFwhm(science.psf)
         except (lsst.pex.exceptions.InvalidParameterError, lsst.pex.exceptions.RangeError):
             self.log.info("Unable to evaluate PSF at the average position. "
                           "Evaluting PSF on a grid of points."
                           )
-            templatePsfSize = evaluateMeanPsfFwhm(template,
-                                                  fwhmExposureBuffer=fwhmExposureBuffer,
-                                                  fwhmExposureGrid=fwhmExposureGrid
-                                                  )
-            sciencePsfSize = evaluateMeanPsfFwhm(science,
-                                                 fwhmExposureBuffer=fwhmExposureBuffer,
-                                                 fwhmExposureGrid=fwhmExposureGrid
-                                                 )
-        self.log.info("Science PSF FWHM: %f pixels", sciencePsfSize)
-        self.log.info("Template PSF FWHM: %f pixels", templatePsfSize)
-        self.metadata["sciencePsfSize"] = sciencePsfSize
-        self.metadata["templatePsfSize"] = templatePsfSize
+            self.templatePsfSize = evaluateMeanPsfFwhm(template,
+                                                       fwhmExposureBuffer=fwhmExposureBuffer,
+                                                       fwhmExposureGrid=fwhmExposureGrid
+                                                       )
+            self.sciencePsfSize = evaluateMeanPsfFwhm(science,
+                                                      fwhmExposureBuffer=fwhmExposureBuffer,
+                                                      fwhmExposureGrid=fwhmExposureGrid
+                                                      )
+        self.log.info("Science PSF FWHM: %f pixels", self.sciencePsfSize)
+        self.log.info("Template PSF FWHM: %f pixels", self.templatePsfSize)
+        self.metadata["sciencePsfSize"] = self.sciencePsfSize
+        self.metadata["templatePsfSize"] = self.templatePsfSize
 
         #  Calculate estimated image depths, i.e., limiting magnitudes
-        maglim_science = self._calculateMagLim(science, fallbackPsfSize=sciencePsfSize)
+        maglim_science = self._calculateMagLim(science, fallbackPsfSize=self.sciencePsfSize)
         fluxlim_science = (maglim_science*u.ABmag).to_value(u.nJy)
-        maglim_template = self._calculateMagLim(template, fallbackPsfSize=templatePsfSize)
+        maglim_template = self._calculateMagLim(template, fallbackPsfSize=self.templatePsfSize)
         if np.isnan(maglim_template):
             self.log.info("Cannot evaluate template limiting mag; adopting science limiting mag for diffim")
             maglim_diffim = maglim_science
@@ -428,7 +428,7 @@ def run(self, template, science, sources, visitSummary=None):
                                           fwhmExposureBuffer=fwhmExposureBuffer,
                                           fwhmExposureGrid=fwhmExposureGrid)
             if convolveTemplate:
-                if sciencePsfSize < templatePsfSize:
+                if self.sciencePsfSize < self.templatePsfSize:
                     self.log.info("Average template PSF size is greater, "
                                   "but science PSF greater in one dimension: convolving template image.")
                 else:
@@ -505,8 +505,14 @@ def runConvolveTemplate(self, template, science, selectSources):
             if self.config.allowKernelSourceDetection:
                 self.log.warning("Error encountered trying to construct the matching kernel"
                                  f" Running source detection and retrying. {e}")
+                kernelSize = self.makeKernel.makeKernelBasisList(
+                    self.templatePsfSize, self.sciencePsfSize)[0].getWidth()
+                sigmaToFwhm = 2*np.log(2*np.sqrt(2))
+                candidateList = self.makeKernel.makeCandidateList(template, science, kernelSize,
+                                                                  candidateList=None,
+                                                                  sigma=self.sciencePsfSize/sigmaToFwhm)
                 kernelSources = self.makeKernel.selectKernelSources(template, science,
-                                                                    candidateList=None,
+                                                                    candidateList=candidateList,
                                                                     preconvolved=False)
                 kernelResult = self.makeKernel.run(template, science, kernelSources,
                                                    preconvolved=False)