It depends on several implementation details that involves memory management, data structures, and heuristics.
You can achieve O(1) insertion with a Quadtree if you implement the optimizations described by L. Spiro in this post (originally described in GPG 4 IIRC):
but I can't talk more about this because I never needed to implement such data structure.
As for AABB trees, one detail is the way the nodes are stored in the memory. For both static and dynamic tree is possible to store their nodes in an array in an attempt to decrease memory access time when traversing the tree. For an array-based static tree the insertion is simple. But for an array-based dynamic tree the operations are not so trivial. A free list of nodes needs to be maintained in the tree for quick node allocation when inserting a new leaf. It is also recommended to inflate the node's AABB by some units such that becomes possible not re-inserting the node into the tree in a future time, when updating the AABB. For example, that could be done by checking if the new AABB is still contained in the old AABB. Another optimization is to predictively extend the new AABB by some units in the direction of motion of the object associated with the node.
Here is an example implementation if you need help implementing the dynamic tree with the optmizations/heuristics I've mentioned above:
Here are some nice slides by Erwin