@@ -7132,8 +7132,8 @@ def test_auto_numticks_log():
     fig, ax = plt.subplots()
     mpl.rcParams['axes.autolimit_mode'] = 'round_numbers'
     ax.loglog([1e-20, 1e5], [1e-16, 10])
-    assert (np.log10(ax.get_xticks()) == np.arange(-26, 18, 4)).all()
-    assert (np.log10(ax.get_yticks()) == np.arange(-20, 10, 3)).all()
+    assert_array_equal(np.log10(ax.get_xticks()), np.arange(-26, 11, 4))
+    assert_array_equal(np.log10(ax.get_yticks()), np.arange(-20, 5, 3))
 
 
 def test_broken_barh_empty():
 
@@ -597,7 +597,7 @@ def test_colorbar_renorm():
     norm = LogNorm(z.min(), z.max())
     im.set_norm(norm)
     np.testing.assert_allclose(cbar.ax.yaxis.get_majorticklocs(),
-                               np.logspace(-10, 7, 18))
+                               np.logspace(-9, 6, 16))
     # note that set_norm removes the FixedLocator...
     assert np.isclose(cbar.vmin, z.min())
     cbar.set_ticks([1, 2, 3])
 
@@ -332,13 +332,11 @@ def test_basic(self):
         with pytest.raises(ValueError):
             loc.tick_values(0, 1000)
 
-        test_value = np.array([1.00000000e-05, 1.00000000e-03, 1.00000000e-01,
-                               1.00000000e+01, 1.00000000e+03, 1.00000000e+05,
-                               1.00000000e+07, 1.000000000e+09])
+        test_value = np.array([1e-5, 1e-3, 1e-1, 1e+1, 1e+3, 1e+5, 1e+7])
         assert_almost_equal(loc.tick_values(0.001, 1.1e5), test_value)
 
         loc = mticker.LogLocator(base=2)
-        test_value = np.array([0.5, 1., 2., 4., 8., 16., 32., 64., 128., 256.])
+        test_value = np.array([.5, 1., 2., 4., 8., 16., 32., 64., 128.])
         assert_almost_equal(loc.tick_values(1, 100), test_value)
 
     def test_polar_axes(self):
@@ -377,7 +375,7 @@ def test_tick_values_correct(self):
                                1.e+01, 2.e+01, 5.e+01, 1.e+02, 2.e+02, 5.e+02,
                                1.e+03, 2.e+03, 5.e+03, 1.e+04, 2.e+04, 5.e+04,
                                1.e+05, 2.e+05, 5.e+05, 1.e+06, 2.e+06, 5.e+06,
-                               1.e+07, 2.e+07, 5.e+07, 1.e+08, 2.e+08, 5.e+08])
+                               1.e+07, 2.e+07, 5.e+07])
         assert_almost_equal(ll.tick_values(1, 1e7), test_value)
 
     def test_tick_values_not_empty(self):
@@ -387,8 +385,7 @@ def test_tick_values_not_empty(self):
                                1.e+01, 2.e+01, 5.e+01, 1.e+02, 2.e+02, 5.e+02,
                                1.e+03, 2.e+03, 5.e+03, 1.e+04, 2.e+04, 5.e+04,
                                1.e+05, 2.e+05, 5.e+05, 1.e+06, 2.e+06, 5.e+06,
-                               1.e+07, 2.e+07, 5.e+07, 1.e+08, 2.e+08, 5.e+08,
-                               1.e+09, 2.e+09, 5.e+09])
+                               1.e+07, 2.e+07, 5.e+07, 1.e+08, 2.e+08, 5.e+08])
         assert_almost_equal(ll.tick_values(1, 1e8), test_value)
 
     def test_multiple_shared_axes(self):
@@ -1913,14 +1910,28 @@ def test_bad_locator_subs(sub):
         ll.set_params(subs=sub)
 
 
-@pytest.mark.parametrize('numticks', [1, 2, 3, 9])
+@pytest.mark.parametrize("numticks, lims, ticks", [
+    (1, (.5, 5), [.1, 1, 10]),
+    (2, (.5, 5), [.1, 1, 10]),
+    (3, (.5, 5), [.1, 1, 10]),
+    (9, (.5, 5), [.1, 1, 10]),
+    (1, (.5, 50), [.1, 10, 1_000]),
+    (2, (.5, 50), [.1, 1, 10, 100]),
+    (3, (.5, 50), [.1, 1, 10, 100]),
+    (9, (.5, 50), [.1, 1, 10, 100]),
+    (1, (.5, 500), [.1, 10, 1_000]),
+    (2, (.5, 500), [.01, 1, 100, 10_000]),
+    (3, (.5, 500), [.1, 1, 10, 100, 1_000]),
+    (9, (.5, 500), [.1, 1, 10, 100, 1_000]),
+    (1, (.5, 5000), [.1, 100, 100_000]),
+    (2, (.5, 5000), [.001, 1, 1_000, 1_000_000]),
+    (3, (.5, 5000), [.001, 1, 1_000, 1_000_000]),
+    (9, (.5, 5000), [.1, 1, 10, 100, 1_000, 10_000]),
+])
 @mpl.style.context('default')
-def test_small_range_loglocator(numticks):
-    ll = mticker.LogLocator()
-    ll.set_params(numticks=numticks)
-    for top in [5, 7, 9, 11, 15, 50, 100, 1000]:
-        ticks = ll.tick_values(.5, top)
-        assert (np.diff(np.log10(ll.tick_values(6, 150))) == 1).all()
+def test_small_range_loglocator(numticks, lims, ticks):
+    ll = mticker.LogLocator(numticks=numticks)
+    assert_array_equal(ll.tick_values(*lims), ticks)
 
 
 def test_NullFormatter():
 
@@ -2403,14 +2403,22 @@ def __call__(self):
         vmin, vmax = self.axis.get_view_interval()
         return self.tick_values(vmin, vmax)
 
+    def _log_b(self, x):
+        # Use specialized logs if possible, as they can be more accurate; e.g.
+        # log(.001) / log(10) = -2.999... (whether math.log or np.log) due to
+        # floating point error.
+        return (np.log10(x) if self._base == 10 else
+                np.log2(x) if self._base == 2 else
+                np.log(x) / np.log(self._base))
+
     def tick_values(self, vmin, vmax):
         if self.numticks == 'auto':
             if self.axis is not None:
-                numticks = np.clip(self.axis.get_tick_space(), 2, 9)
+                nt = np.clip(self.axis.get_tick_space(), 2, 9)
             else:
-                numticks = 9
+                nt = 9
         else:
-            numticks = self.numticks
+            nt = self.numticks
 
         b = self._base
         if vmin <= 0.0:
@@ -2421,17 +2429,16 @@ def tick_values(self, vmin, vmax):
                 raise ValueError(
                     "Data has no positive values, and therefore cannot be log-scaled.")
 
-        _log.debug('vmin %s vmax %s', vmin, vmax)
-
         if vmax < vmin:
             vmin, vmax = vmax, vmin
-        log_vmin = math.log(vmin) / math.log(b)
-        log_vmax = math.log(vmax) / math.log(b)
-
-        numdec = math.floor(log_vmax) - math.ceil(log_vmin)
+        # Min and max exponents -- float and int versions.
+        efmin, efmax = self._log_b([vmin, vmax])
+        emin = math.ceil(efmin)
+        emax = math.floor(efmax)
+        nd = emax - emin + 1  # Total number of decade ticks available.
 
         if isinstance(self._subs, str):
-            if numdec > 10 or b < 3:
+            if nd >= 10 or b < 3:
                 if self._subs == 'auto':
                     return np.array([])  # no minor or major ticks
                 else:
@@ -2442,35 +2449,70 @@ def tick_values(self, vmin, vmax):
         else:
             subs = self._subs
 
-        # Get decades between major ticks.
-        stride = (max(math.ceil(numdec / (numticks - 1)), 1)
-                  if mpl.rcParams['_internal.classic_mode'] else
-                  numdec // numticks + 1)
-
-        # if we have decided that the stride is as big or bigger than
-        # the range, clip the stride back to the available range - 1
-        # with a floor of 1.  This prevents getting axis with only 1 tick
-        # visible.
-        if stride >= numdec:
-            stride = max(1, numdec - 1)
-
-        # Does subs include anything other than 1?  Essentially a hack to know
-        # whether we're a major or a minor locator.
-        have_subs = len(subs) > 1 or (len(subs) == 1 and subs[0] != 1.0)
-
-        decades = np.arange(math.floor(log_vmin) - stride,
-                            math.ceil(log_vmax) + 2 * stride, stride)
-
-        if have_subs:
-            if stride == 1:
-                ticklocs = np.concatenate(
-                    [subs * decade_start for decade_start in b ** decades])
+        # Get decades between major ticks.  Always return an extra tick outside
+        # the lower and the upper limit: QuadContourSet._autolev relies on
+        # this.
+        if mpl.rcParams["_internal.classic_mode"]:  # keep historic formulas
+            stride = max(math.ceil((nd - 1) / (nt - 1)), 1)
+            decades = np.arange(emin - stride, emax + stride + 1, stride)
+        else:
+            # Find the largest number of ticks, no more than the requested
+            # number, that can actually be drawn (e.g., with 9 decades ticks,
+            # no stride yields 7 ticks).  For a given value of the stride *s*,
+            # there are either floor(nd/s) or ceil(nd/s) ticks depending on the
+            # offset.  Pick the smallest stride such that floor(nd/s) < nt,
+            # i.e. nd/s < nt+1, then re-set nt to ceil(...) if acceptable, else
+            # to floor(...) (which must then equal the original nt, i.e. nt is
+            # kept unchanged).
+            stride = nd // (nt + 1) + 1
+            nt1 = math.ceil(nd / stride)
+            if nt1 <= nt:
+                nt = nt1
+            else:
+                assert nt1 == nt + 1
+            if nt == 0:
+                decades = [emin - 1, emax + 1]
+                stride = decades[1] - decades[0]
+            elif nt == 1:  # Draw single tick close to center.
+                mid = round((efmin + efmax) / 2)
+                stride = max(mid - (emin - 1), (emax + 1) - stride)
+                decades = [mid - stride, mid, mid + stride]
+            else:
+                # Pick the largest s that yields this actual nt (e.g., with 15
+                # decades, strides of 5, 6, or 7 *can* yield 3 ticks; picking a
+                # larger stride minimizes unticked space at the ends).  First
+                # try for
+                #     ceil(nd/s) == nt, i.e. nd/nt <= s < nd/(nt-1),
+                # else fallback to
+                #     floor(nd/s) == nt, i.e. nd/(nt+1) < s <= nd/nt.
+                # One of these cases must have an integer solution (given the
+                # choice of nt above).
+                # In the second case, an offset must be added to that only nt
+                # ticks are drawn (e.g. with 19 decades (0 to 18 incl.) and 6
+                # ticks, they should must be drawn at exponents 1, 4, 7, 10,
+                # 13, and 16).
+                stride = (nd - 1) // (nt - 1)
+                if stride < nd / nt:  # fallback to second case
+                    stride = nd // nt
+                    assert stride > nd / (nt + 1)
+                    offset = nd % stride
+                else:
+                    offset = 0
+                decades = range(emin + offset - stride, emax + stride + 1, stride)
+
+        # Guess whether we're a minor locator, based on whether subs include
+        # anything other than 1.
+        is_minor = len(subs) > 1 or (len(subs) == 1 and subs[0] != 1.0)
+        if is_minor:
+            if stride == 1 or nd <= 1:
+                # Minor ticks start in the decade preceding the first major tick.
+                ticklocs = np.concatenate([
+                    subs * b**decade for decade in range(emin - 1, emax + 1)])
             else:
                 ticklocs = np.array([])
         else:
-            ticklocs = b ** decades
+            ticklocs = b ** np.array(decades)
 
-        _log.debug('ticklocs %r', ticklocs)
         if (len(subs) > 1
                 and stride == 1
                 and ((vmin <= ticklocs) & (ticklocs <= vmax)).sum() <= 1):