diff --git a/kgb/spies.py b/kgb/spies.py
index 45f299a580aab37d2584e0632c38334b09f6892f..5ed4595741beb9a5819d560899168424c17fd781 100644
--- a/kgb/spies.py
+++ b/kgb/spies.py
@@ -311,11 +311,17 @@ class FunctionSpy(object):
 
         if (self.owner is not None and
             self.func_type == self.TYPE_BOUND_METHOD and
-            not inspect.isclass(self.owner)):
+            (not inspect.isclass(self.owner) or
+             any(
+                inspect.isclass(parent_cls) and
+                hasattr(parent_cls, self.func_name)
+                for parent_cls in self.owner.__bases__
+             ))):
             # Construct a replacement function for this method, and
-            # re-assign it to the instance. We do this in order to
-            # prevent two spies on the same function on two separate
-            # instances of the class from conflicting with each other.
+            # re-assign it to the owner. We do this in order to prevent
+            # two spies on the same method on two separate instances
+            # of the class, or two subclasses of a common class owning the
+            # method from conflicting with each other.
             real_func = self._clone_function(real_func)
             method_type_args = [real_func, self.owner]
 
diff --git a/kgb/tests/test_function_spy.py b/kgb/tests/test_function_spy.py
index 545ef14e631c1d67d68ecd0e22ace19f7d3fe277..cddd78a1cef7c13927dc69187ddb6d374612c8e1 100644
--- a/kgb/tests/test_function_spy.py
+++ b/kgb/tests/test_function_spy.py
@@ -192,6 +192,47 @@ class FunctionSpyTests(TestCase):
         self.assertEqual(spy.func_type, spy.TYPE_BOUND_METHOD)
         self.assertIsInstance(MathClass.class_do_math, types.MethodType)
 
+    def test_construction_with_classmethod_on_parent(self):
+        """Testing FunctionSpy construction with classmethod from parent of
+        class
+        """
+        class MyParent(object):
+            @classmethod
+            def foo(self):
+                pass
+
+        class MyObject(MyParent):
+            pass
+
+        obj = MyObject()
+        orig_method = obj.foo
+
+        spy = self.agency.spy_on(MyObject.foo)
+
+        self.assertTrue(hasattr(MyObject.foo, 'spy'))
+        self.assertFalse(hasattr(MyParent.foo, 'spy'))
+        self.assertIs(MyObject.foo.spy, spy)
+        self.assertEqual(spy.func_name, 'foo')
+        self.assertEqual(spy.func_type, spy.TYPE_BOUND_METHOD)
+        self.assertEqual(spy.owner, MyObject)
+
+        if isinstance(orig_method, types.FunctionType):
+            # Python 3
+            self.assertIs(MyObject.foo, orig_method)
+        elif isinstance(orig_method, types.MethodType):
+            # Python 2
+            self.assertIsNot(MyObject.foo, orig_method)
+        else:
+            self.fail('Method has an unexpected type %r' % type(orig_method))
+
+        obj2 = MyObject()
+        self.assertTrue(hasattr(obj2.foo, 'spy'))
+        self.assertIs(obj2.foo.spy, MyObject.foo.spy)
+        self.assertIsInstance(obj2.foo, types.MethodType)
+
+        obj3 = MyParent()
+        self.assertFalse(hasattr(obj3.foo, 'spy'))
+
     def test_construction_with_falsy_im_self(self):
         """Testing FunctionSpy construction with a falsy function.im_self"""
         class MyObject(dict):
@@ -862,6 +903,27 @@ class FunctionSpyTests(TestCase):
         spy.unspy()
         self.assertEqual(MathClass.class_do_math.__dict__, func_dict)
 
+    def test_unspy_with_classmethod_on_parent(self):
+        """Testing FunctionSpy.unspy with classmethod on parent class"""
+        class MyParent(object):
+            @classmethod
+            def foo(self):
+                pass
+
+        class MyObject(MyParent):
+            pass
+
+        parent_func_dict = MyParent.foo.__dict__.copy()
+        obj_func_dict = MyObject.foo.__dict__.copy()
+
+        spy = self.agency.spy_on(MyObject.foo)
+        self.assertNotEqual(MyObject.foo.__dict__, obj_func_dict)
+        self.assertEqual(MyParent.foo.__dict__, parent_func_dict)
+
+        spy.unspy()
+        self.assertEqual(MyObject.foo.__dict__, obj_func_dict)
+        self.assertEqual(MyParent.foo.__dict__, parent_func_dict)
+
     def test_called_with(self):
         """Testing FunctionSpy.called_with"""
         obj = MathClass()