Should I trust in RVO or use move semantic?

Question

my question is how to write function which creates object.

For example:

class MyVector {
public:
  std::vector<int> vec_;
  MyVector() = default;
  MyVector(const MyVector&) = default;
  MyVector& operator=(const MyVector&) = default;
  MyVector(MyVector&&) = default;
  MyVector& operator=(MyVector&&) = default;
  void add(int value) {
    vec_.push_back(value);
  }
};

// Ver. 1 of functions:

std::string to_string(const MyVector& vec) {
    std::string vecStr;
    for(const auto value: vec.vec_) {
        vecStr += std::to_string(value);
    }
    return vecStr;
}

MyVector create_vector() {
    MyVector vec;
    for(int i = 0; i < 1000; ++i) {
        cout << i << endl;
        vec.add(i);
    }
    return vec;
}

// Ver. 2 of functions:

std::string toString(const MyVector& vec) {
    std::string vecStr;
    for(const auto value: vec.vec_) {
        vecStr += std::to_string(value);
    }
    return std::move(vecStr);
}

MyVector createVector() {
    MyVector vec;
    for(int i = 0; i < 1000; ++i) {
        vec.add(i);
    }
    return std::move(vec);
}

main:

int main()
{
    MyVector vec1 = create_vector();
    MyVector vec2 = std::move(createVector());
    std::string vec1Str = to_string(vec1);
    std::string vec2Str = std::move(toString(vec2));
    std::cout << vec1Str << std::endl;
    std::cout << vec2Str << std::endl;

    return 0;
}

Which version of functions is preferred? Do Ver.1 always guarantee RVO even if the content of vector wont be a fundamental type?