diff --git a/Orthtree/include/CGAL/Orthtree.h b/Orthtree/include/CGAL/Orthtree.h
index 0e2a79e816f..4b39fde2767 100644
--- a/Orthtree/include/CGAL/Orthtree.h
+++ b/Orthtree/include/CGAL/Orthtree.h
@@ -396,7 +396,7 @@ public:
 
         // Skip if this neighbor is a direct sibling (it's guaranteed to be the same depth)
         // TODO: This check might be redundant, if it doesn't affect performance maybe I could remove it
-        if (neighbor->parent() == node->parent())
+        if (&parent(*neighbor) == &parent(*node))
           continue;
 
         // If it's already been split, skip it
@@ -639,6 +639,20 @@ public:
   /// \name Node Access
   /// @{
 
+  /*!
+    \brief returns this node's parent.
+    \pre `!is_root()`
+   */
+  const Node& parent(const Node& node) const {
+    CGAL_precondition (!node.is_root());
+    return *node.m_parent;
+  }
+
+  Node& parent(Node& node) {
+    CGAL_precondition (!node.is_root());
+    return *node.m_parent;
+  }
+
   using Children = typename Node::Children;
 
   Children& children(Node& node) {
@@ -836,11 +850,11 @@ public:
     // Check if this child has the opposite sign along the direction's axis
     if (node.local_coordinates()[dimension] != sign) {
       // This means the adjacent node is a direct sibling, the offset can be applied easily!
-      return &children(*node.parent())[node.local_coordinates().to_ulong() + offset];
+      return &children(parent(node))[node.local_coordinates().to_ulong() + offset];
     }
 
     // Find the parent's neighbor in that direction, if it exists
-    const Node* adjacent_node_of_parent = adjacent_node(*node.parent(), direction);
+    const Node* adjacent_node_of_parent = adjacent_node(parent(node), direction);
 
     // If the parent has no neighbor, then this node doesn't have one
     if (adjacent_node_of_parent == nullptr) return nullptr;
diff --git a/Orthtree/include/CGAL/Orthtree/Node.h b/Orthtree/include/CGAL/Orthtree/Node.h
index 98acd0bd2cb..c75ac1b9a00 100644
--- a/Orthtree/include/CGAL/Orthtree/Node.h
+++ b/Orthtree/include/CGAL/Orthtree/Node.h
@@ -226,20 +226,6 @@ public:
 
   /// @}
 
-  /// \name Adjacency
-  /// @{
-
-  /*!
-    \brief returns this node's parent.
-    \pre `!is_root()`
-   */
-  const Self* parent() const {
-    CGAL_precondition (!is_root());
-    return m_parent;
-  }
-
-  /// @}
-
   /// \name Point Range
   /// @{
 
diff --git a/Orthtree/include/CGAL/Orthtree/Traversals.h b/Orthtree/include/CGAL/Orthtree/Traversals.h
index 6e51e3ce77c..5f3dcc54e74 100644
--- a/Orthtree/include/CGAL/Orthtree/Traversals.h
+++ b/Orthtree/include/CGAL/Orthtree/Traversals.h
@@ -36,9 +36,9 @@ namespace Orthtrees {
 // todo: all of these could be members of Orthtree
 
 template <typename Tree>
-const typename Tree::Node* next_sibling(const Tree &orthtree, const typename Tree::Node* n) {
+const typename Tree::Node* next_sibling(const Tree& orthtree, const typename Tree::Node* n) {
 
-  // Passing null returns the first node
+  // todo: maybe this should take a reference?
   if (nullptr == n)
     return nullptr;
 
@@ -55,30 +55,29 @@ const typename Tree::Node* next_sibling(const Tree &orthtree, const typename Tre
     return nullptr;
 
   // Otherwise, return the next child
-  return &(orthtree.children(*n->parent())[index + 1]);
+  return &(orthtree.children(orthtree.parent(*n))[index + 1]);
 }
 
 template <typename Tree>
-const typename Tree::Node* next_sibling_up(const Tree &orthtree, const typename Tree::Node* n) {
+const typename Tree::Node* next_sibling_up(const Tree& orthtree, const typename Tree::Node* n) {
 
   if (!n || n->is_root()) return nullptr;
 
-  auto up = n->parent();
+  auto up = &orthtree.parent(*n);
   while (nullptr != up) {
 
     if (nullptr != next_sibling(orthtree, up))
       return next_sibling(orthtree, up);
 
-    if (up->is_root()) return nullptr;
-
-    up = up->parent();
+    // todo: this could be cleaned up; it's probably not necessary to involve pointers here
+    up = up->is_root() ? nullptr : &orthtree.parent(*up);
   }
 
   return nullptr;
 }
 
 template <typename Tree>
-const typename Tree::Node* deepest_first_child(const Tree &orthtree, const typename Tree::Node* n) {
+const typename Tree::Node* deepest_first_child(const Tree& orthtree, const typename Tree::Node* n) {
 
   if (n == nullptr)
     return nullptr;
@@ -92,7 +91,7 @@ const typename Tree::Node* deepest_first_child(const Tree &orthtree, const typen
 
 
 template <typename Tree>
-const typename Tree::Node* first_child_at_depth(const Tree &orthtree, const typename Tree::Node* n, std::size_t depth) {
+const typename Tree::Node* first_child_at_depth(const Tree& orthtree, const typename Tree::Node* n, std::size_t depth) {
 
   if (!n)
     return nullptr;