@@ -16,8 +16,8 @@
 
 import six
 
-import warnings
 from operator import itemgetter
+import warnings
 
 import numpy as np
 
@@ -73,6 +73,7 @@ class AxesStack(Stack):
 
     """
     def __init__(self):
+        cbook.warn_deprecated("2.0")
         Stack.__init__(self)
         self._ind = 0
 
@@ -157,6 +158,68 @@ def __contains__(self, a):
         return a in self.as_list()
 
 
+class _AxesStack(object):
+    """Lightweight stack that tracks Axes in a Figure.
+    """
+
+    # We do not subclass the Stack class from cbook to avoid hashability
+    # issues.
+
+    def __init__(self):
+        self._keys = []
+        self._axes = []
+        self._axes_ordered = []
+
+    def as_list(self):
+        """Copy of the list of axes, in the order of insertion.
+        """
+        return self._axes_ordered[:]
+
+    def get(self, key):
+        """Find the axes corresponding to a key; defaults to `None`.
+        """
+        try:
+            return self._axes[self._keys.index(key)]
+        except ValueError:
+            return None
+
+    def current_key_axes(self):
+        """Return the topmost key, axes pair, or `None, None` if empty.
+        """
+        return (self._keys[-1], self._axes[-1]) if self._keys else (None, None)
+
+    def add(self, key, ax):
+        """Append a key, axes pair, unless the axes are already present.
+        """
+        # Skipping existing Axes is needed to support calling `add_axes` with
+        # an already existing Axes.
+        if ax in self._axes_ordered:
+            return
+        self._keys.append(key)
+        self._axes.append(ax)
+        self._axes_ordered.append(ax)
+
+    def bubble(self, ax):
+        """Move an axes and its corresponding key to the top.
+        """
+        idx = self._axes.index(ax)
+        self._keys.append(self._keys[idx])
+        self._axes.append(self._axes[idx])
+        del self._keys[idx], self._axes[idx]
+
+    def remove(self, ax):
+        """Remove an axes and its corresponding key.
+        """
+        del self._keys[self._axes.index(ax)]
+        self._axes.remove(ax)
+        self._axes_ordered.remove(ax)
+
+    def clear(self):
+        """Clear the stack.
+        """
+        del self._keys[:], self._axes[:], self._axes_ordered[:]
+
+
 class SubplotParams(object):
     """
     A class to hold the parameters for a subplot
@@ -350,7 +413,7 @@ def __init__(self,
         self.subplotpars = subplotpars
         self.set_tight_layout(tight_layout)
 
-        self._axstack = AxesStack()  # track all figure axes and current axes
+        self._axstack = _AxesStack()  # track all figure axes and current axes
         self.clf()
         self._cachedRenderer = None
 
@@ -398,10 +461,8 @@ def show(self, warn=True):
                 "matplotlib is currently using a non-GUI backend, "
                 "so cannot show the figure")
 
-    def _get_axes(self):
-        return self._axstack.as_list()
-
-    axes = property(fget=_get_axes, doc="Read-only: list of axes in Figure")
+    axes = property(lambda self: self._axstack.as_list(),
+                    doc="Read-only: list of axes in Figure")
 
     def _get_dpi(self):
         return self._dpi
@@ -812,36 +873,6 @@ def delaxes(self, a):
             func(self)
         self.stale = True
 
-    def _make_key(self, *args, **kwargs):
-        'make a hashable key out of args and kwargs'
-
-        def fixitems(items):
-            #items may have arrays and lists in them, so convert them
-            # to tuples for the key
-            ret = []
-            for k, v in items:
-                # some objects can define __getitem__ without being
-                # iterable and in those cases the conversion to tuples
-                # will fail. So instead of using the iterable(v) function
-                # we simply try and convert to a tuple, and proceed if not.
-                try:
-                    v = tuple(v)
-                except Exception:
-                    pass
-                ret.append((k, v))
-            return tuple(ret)
-
-        def fixlist(args):
-            ret = []
-            for a in args:
-                if iterable(a):
-                    a = tuple(a)
-                ret.append(a)
-            return tuple(ret)
-
-        key = fixlist(args), fixitems(six.iteritems(kwargs))
-        return key
-
     @docstring.dedent_interpd
     def add_axes(self, *args, **kwargs):
         """
@@ -895,9 +926,9 @@ def add_axes(self, *args, **kwargs):
 
         # shortcut the projection "key" modifications later on, if an axes
         # with the exact args/kwargs exists, return it immediately.
-        key = self._make_key(*args, **kwargs)
+        key = (args, kwargs)
         ax = self._axstack.get(key)
-        if ax is not None:
+        if ax:
             self.sca(ax)
             return ax
 
@@ -914,7 +945,7 @@ def add_axes(self, *args, **kwargs):
             # check that an axes of this type doesn't already exist, if it
             # does, set it as active and return it
             ax = self._axstack.get(key)
-            if ax is not None and isinstance(ax, projection_class):
+            if isinstance(ax, projection_class):
                 self.sca(ax)
                 return ax
 
@@ -988,15 +1019,14 @@ def add_subplot(self, *args, **kwargs):
                 raise ValueError(msg)
             # make a key for the subplot (which includes the axes object id
             # in the hash)
-            key = self._make_key(*args, **kwargs)
+            key = (args, kwargs)
         else:
             projection_class, kwargs, key = process_projection_requirements(
                 self, *args, **kwargs)
 
             # try to find the axes with this key in the stack
             ax = self._axstack.get(key)
-
-            if ax is not None:
+            if ax:
                 if isinstance(ax, projection_class):
                     # the axes already existed, so set it as active & return
                     self.sca(ax)
@@ -1496,7 +1526,7 @@ def _gci(self):
         do not use elsewhere.
         """
         # Look first for an image in the current Axes:
-        cax = self._axstack.current_key_axes()[1]
+        ckey, cax = self._axstack.current_key_axes()
         if cax is None:
             return None
         im = cax._gci()
 
@@ -103,11 +103,7 @@ def process_projection_requirements(figure, *args, **kwargs):
         raise TypeError('projection must be a string, None or implement a '
                             '_as_mpl_axes method. Got %r' % projection)
 
-    # Make the key without projection kwargs, this is used as a unique
-    # lookup for axes instances
-    key = figure._make_key(*args, **kwargs)
-
-    return projection_class, kwargs, key
+    return projection_class, kwargs, (args, kwargs)
 
 
 def get_projection_names():