diff --git a/src/heap/heap-inl.h b/src/heap/heap-inl.h
index e121db17f5..6f7c060d70 100644
--- a/src/heap/heap-inl.h
+++ b/src/heap/heap-inl.h
@@ -123,11 +123,12 @@ AllocationResult Heap::AllocateOneByteInternalizedString(
   // Compute map and object size.
   Map* map = one_byte_internalized_string_map();
   int size = SeqOneByteString::SizeFor(str.length());
+  AllocationSpace space = SelectSpace(size, TENURED);
 
   // Allocate string.
   HeapObject* result = nullptr;
   {
-    AllocationResult allocation = AllocateRaw(size, OLD_SPACE, OLD_SPACE);
+    AllocationResult allocation = AllocateRaw(size, space, OLD_SPACE);
     if (!allocation.To(&result)) return allocation;
   }
 
@@ -154,11 +155,12 @@ AllocationResult Heap::AllocateTwoByteInternalizedString(Vector<const uc16> str,
   // Compute map and object size.
   Map* map = internalized_string_map();
   int size = SeqTwoByteString::SizeFor(str.length());
+  AllocationSpace space = SelectSpace(size, TENURED);
 
   // Allocate string.
   HeapObject* result = nullptr;
   {
-    AllocationResult allocation = AllocateRaw(size, OLD_SPACE, OLD_SPACE);
+    AllocationResult allocation = AllocateRaw(size, space, OLD_SPACE);
     if (!allocation.To(&result)) return allocation;
   }
 
@@ -204,37 +206,33 @@ AllocationResult Heap::AllocateRaw(int size_in_bytes, AllocationSpace space,
   isolate_->counters()->objs_since_last_young()->Increment();
 #endif
 
-  bool large_object = size_in_bytes > Page::kMaxRegularHeapObjectSize;
   HeapObject* object = nullptr;
   AllocationResult allocation;
   if (NEW_SPACE == space) {
-    if (!large_object) {
-      allocation = new_space_.AllocateRaw(size_in_bytes, alignment);
-      if (always_allocate() && allocation.IsRetry() &&
-          retry_space != NEW_SPACE) {
-        space = retry_space;
-      }
+    allocation = new_space_.AllocateRaw(size_in_bytes, alignment);
+    if (always_allocate() && allocation.IsRetry() && retry_space != NEW_SPACE) {
+      space = retry_space;
     } else {
-      space = LO_SPACE;
+      if (allocation.To(&object)) {
+        OnAllocationEvent(object, size_in_bytes);
+      }
+      return allocation;
     }
   }
 
   if (OLD_SPACE == space) {
-    if (!large_object) {
-      allocation = old_space_->AllocateRaw(size_in_bytes, alignment);
-    } else {
-      allocation = lo_space_->AllocateRaw(size_in_bytes, NOT_EXECUTABLE);
-    }
+    allocation = old_space_->AllocateRaw(size_in_bytes, alignment);
   } else if (CODE_SPACE == space) {
     if (size_in_bytes <= code_space()->AreaSize()) {
       allocation = code_space_->AllocateRawUnaligned(size_in_bytes);
     } else {
+      // Large code objects are allocated in large object space.
       allocation = lo_space_->AllocateRaw(size_in_bytes, EXECUTABLE);
     }
   } else if (LO_SPACE == space) {
-    DCHECK(large_object);
     allocation = lo_space_->AllocateRaw(size_in_bytes, NOT_EXECUTABLE);
-  } else if (MAP_SPACE == space) {
+  } else {
+    DCHECK(MAP_SPACE == space);
     allocation = map_space_->AllocateRawUnaligned(size_in_bytes);
   }
   if (allocation.To(&object)) {
diff --git a/src/heap/heap.cc b/src/heap/heap.cc
index bafce6fc6d..31b93e7199 100644
--- a/src/heap/heap.cc
+++ b/src/heap/heap.cc
@@ -2364,7 +2364,7 @@ AllocationResult Heap::AllocateHeapNumber(double value, MutableMode mode,
   int size = HeapNumber::kSize;
   STATIC_ASSERT(HeapNumber::kSize <= Page::kMaxRegularHeapObjectSize);
 
-  AllocationSpace space = SelectSpace(pretenure);
+  AllocationSpace space = SelectSpace(size, pretenure);
 
   HeapObject* result = nullptr;
   {
@@ -2385,7 +2385,7 @@ AllocationResult Heap::AllocateHeapNumber(double value, MutableMode mode,
     int size = Type::kSize;                                               \
     STATIC_ASSERT(Type::kSize <= Page::kMaxRegularHeapObjectSize);        \
                                                                           \
-    AllocationSpace space = SelectSpace(pretenure);                       \
+    AllocationSpace space = SelectSpace(size, pretenure);                 \
                                                                           \
     HeapObject* result = nullptr;                                         \
     {                                                                     \
@@ -2923,7 +2923,7 @@ AllocationResult Heap::AllocateByteArray(int length, PretenureFlag pretenure) {
     v8::internal::Heap::FatalProcessOutOfMemory("invalid array length", true);
   }
   int size = ByteArray::SizeFor(length);
-  AllocationSpace space = SelectSpace(pretenure);
+  AllocationSpace space = SelectSpace(size, pretenure);
   HeapObject* result = nullptr;
   {
     AllocationResult allocation = AllocateRaw(size, space, OLD_SPACE);
@@ -3134,7 +3134,7 @@ AllocationResult Heap::AllocateFixedTypedArrayWithExternalPointer(
     int length, ExternalArrayType array_type, void* external_pointer,
     PretenureFlag pretenure) {
   int size = FixedTypedArrayBase::kHeaderSize;
-  AllocationSpace space = SelectSpace(pretenure);
+  AllocationSpace space = SelectSpace(size, pretenure);
   HeapObject* result = nullptr;
   {
     AllocationResult allocation = AllocateRaw(size, space, OLD_SPACE);
@@ -3178,7 +3178,7 @@ AllocationResult Heap::AllocateFixedTypedArray(int length,
   ForFixedTypedArray(array_type, &element_size, &elements_kind);
   int size = OBJECT_POINTER_ALIGN(length * element_size +
                                   FixedTypedArrayBase::kDataOffset);
-  AllocationSpace space = SelectSpace(pretenure);
+  AllocationSpace space = SelectSpace(size, pretenure);
 
   HeapObject* object = nullptr;
   AllocationResult allocation = AllocateRaw(
@@ -3393,7 +3393,8 @@ AllocationResult Heap::AllocateJSObjectFromMap(
   FixedArray* properties = empty_fixed_array();
 
   // Allocate the JSObject.
-  AllocationSpace space = SelectSpace(pretenure);
+  int size = map->instance_size();
+  AllocationSpace space = SelectSpace(size, pretenure);
   JSObject* js_obj = nullptr;
   AllocationResult allocation = Allocate(map, space, allocation_site);
   if (!allocation.To(&js_obj)) return allocation;
@@ -3594,11 +3595,12 @@ AllocationResult Heap::AllocateInternalizedStringImpl(T t, int chars,
     map = internalized_string_map();
     size = SeqTwoByteString::SizeFor(chars);
   }
+  AllocationSpace space = SelectSpace(size, TENURED);
 
   // Allocate string.
   HeapObject* result = nullptr;
   {
-    AllocationResult allocation = AllocateRaw(size, OLD_SPACE, OLD_SPACE);
+    AllocationResult allocation = AllocateRaw(size, space, OLD_SPACE);
     if (!allocation.To(&result)) return allocation;
   }
 
@@ -3636,7 +3638,7 @@ AllocationResult Heap::AllocateRawOneByteString(int length,
   DCHECK_GE(String::kMaxLength, length);
   int size = SeqOneByteString::SizeFor(length);
   DCHECK(size <= SeqOneByteString::kMaxSize);
-  AllocationSpace space = SelectSpace(pretenure);
+  AllocationSpace space = SelectSpace(size, pretenure);
 
   HeapObject* result = nullptr;
   {
@@ -3660,7 +3662,7 @@ AllocationResult Heap::AllocateRawTwoByteString(int length,
   DCHECK_GE(String::kMaxLength, length);
   int size = SeqTwoByteString::SizeFor(length);
   DCHECK(size <= SeqTwoByteString::kMaxSize);
-  AllocationSpace space = SelectSpace(pretenure);
+  AllocationSpace space = SelectSpace(size, pretenure);
 
   HeapObject* result = nullptr;
   {
@@ -3795,7 +3797,7 @@ AllocationResult Heap::AllocateRawFixedArray(int length,
     v8::internal::Heap::FatalProcessOutOfMemory("invalid array length", true);
   }
   int size = FixedArray::SizeFor(length);
-  AllocationSpace space = SelectSpace(pretenure);
+  AllocationSpace space = SelectSpace(size, pretenure);
 
   return AllocateRaw(size, space, OLD_SPACE);
 }
@@ -3864,7 +3866,7 @@ AllocationResult Heap::AllocateRawFixedDoubleArray(int length,
                                                 kDoubleAligned);
   }
   int size = FixedDoubleArray::SizeFor(length);
-  AllocationSpace space = SelectSpace(pretenure);
+  AllocationSpace space = SelectSpace(size, pretenure);
 
   HeapObject* object = nullptr;
   {
@@ -3921,9 +3923,10 @@ AllocationResult Heap::AllocateStruct(InstanceType type) {
       return exception();
   }
   int size = map->instance_size();
+  AllocationSpace space = SelectSpace(size, TENURED);
   Struct* result = nullptr;
   {
-    AllocationResult allocation = Allocate(map, OLD_SPACE);
+    AllocationResult allocation = Allocate(map, space);
     if (!allocation.To(&result)) return allocation;
   }
   result->InitializeBody(size);
diff --git a/src/heap/heap.h b/src/heap/heap.h
index 442d4dee1a..3b6fd98da4 100644
--- a/src/heap/heap.h
+++ b/src/heap/heap.h
@@ -1640,8 +1640,10 @@ class Heap {
   static void ScavengeStoreBufferCallback(Heap* heap, MemoryChunk* page,
                                           StoreBufferEvent event);
 
-  // Selects the proper allocation space based on the pretenuring decision.
-  static AllocationSpace SelectSpace(PretenureFlag pretenure) {
+  // Selects the proper allocation space depending on the given object
+  // size and pretenuring decision.
+  static AllocationSpace SelectSpace(int object_size, PretenureFlag pretenure) {
+    if (object_size > Page::kMaxRegularHeapObjectSize) return LO_SPACE;
     return (pretenure == TENURED) ? OLD_SPACE : NEW_SPACE;
   }