The power curve seems to be approximately of the form $P=cv^{2}$, where $P$ is the power, $v$ is the speed and $c$ is a constant that we need to find. To reduce the error I computed the following mean based on your figures
$$\begin{equation*}
c=\sqrt[8]{\frac{25}{5^{2}}\frac{50}{9^{2}}\frac{100}{12.5^{2}}\frac{200}{
17^{2}}\frac{300}{20.5^{2}}\frac{400}{23^{2}}\frac{500}{25^{2}}\frac{600}{
27^{2}}}\approx 0.75.
\end{equation*}$$
So the approximate equation of the form $P=cv^{2}$ is
$$\begin{equation*}
P\approx 0.75v^{2}\qquad \text{(}P\text{ in Watt and }v\text{ in mph),}
\end{equation*}$$
or
$$\begin{equation*}
v\approx 1.16\sqrt{P}.
\end{equation*}$$
This approximation gives
$$\begin{eqnarray*}
v(600) &\approx &28.4 \\
v(300) &\approx &20.1 \\
v(100) &\approx &11.6.
\end{eqnarray*}$$
The best way to handle this kind of problem of modelling data is to use information theoretic approaches.
Kolmogorov complexity
The simplest and completely generic way is to find a (program,input) pair with the shortest total length over a fixed general purpose programming language that when run outputs the data exactly as it is. This is called Kolmogorov complexity. Of course this depends on the chosen programming language, and clearly if you first look at the data you can construct a language purposely tailored to it (see Code Golf SE for some egregious examples). That's not allowed; you must first choose the language once and for all, and use it for every subsequent problem that you want to measure the complexity of the data. Also, the language must be Turing-complete. Common languages such as C++14 or Java 7 are suitable. The lengths of the program and input string is always measured in bits.
Let $K_L(x)$ be the Kolmogorov complexity of string $x$ over Turing-complete programming language $L$.
Why would this work? It can be easily proven that, given Turing-complete languages $L,M$, there is some $c$ such that, for any string $x$ we have $|K_L(x)-K_M(x)| \le c$. Thus for any class of strings the Kolmogorov complexity will be asymptotically correct as the string length goes to $\infty$. For example, the Kolmogorov complexity of the string $x_n$ of exactly $n$ zeros would differ from $\log_2(n)$ by at most $c$, for some constant $c$ that is independent of $n$. So as $n \to \infty$ we have $K_L(x_n) \in θ(\log(n))$.
Since our choice of language does not affect asymptotic Kolmogorov complexity, it is an objective measure of complexity for sufficiently large samples, and using a common language like C/C++ or Java makes it impossible for over-fitting.
Suitability of Kolmogorov complexity
For exact data, Kolmogorov complexity captures precisely the amount of information contained within it (up to a constant as mentioned above). However, it can be proven that there is no Turing-complete language $L$ and program $P$ such that $P(x) = K_L(x)$ for every string $x$. So you cannot hope to determine Kolmogorov complexity in general, not to say find the (program,input) pair that witnesses the complexity!
What you can still do is to find an upper bound, which is exactly what compression algorithms are essentially doing. Given any string $x$, the total length of the string that $x$ is compressed to and the decompression algorithm (written in $L$) is an upper bound on the true Kolmogorov complexity $K_L(x)$.
Nevertheless, most scientific experiments do not produce exact data, so it is pointless to ask for a program that reproduces the measurements exactly, since they are already imprecise and inaccurate. But the same ideas still apply. We just need to cater for noise.
Kolmogorov complexity modulo noise
If the data is a list of pairs $(x_k,y_k)_{k\in\{1..n\}}$, such as in many empirical experiments, and we know that the noise is uniform across the list, we can model the data as $N(P(x_k))=y_k$ where program $P$ is the actual function we seek and $N$ is a random program that models a noisy channel that adds noise. $N$ is written in a Turing-complete language that is additionally allowed to call a function that returns a uniformly random bit (which is independent of previous call results).
Then we want to a pair $(P,N)$ that minimizes what I call the complexity modulo noise defined as $|(P,N)| - \frac{1}{n} \sum_{k=1}^n \log_2(\mathbb{P}(N(P(x_k))=y_k))$. Intuitively, this is the length of the description of the trend and the noise source plus the average information in the noise itself. This is such that if there is no meaningful trend mapping $x$ to $y$, then the complexity modulo noise would be just the number of bits required to specify the noise. On the other hand if there is a trend then it would be captured by a short $P$, and there would be an optimal $N$ since it must be noisy enough to cater for the discrepancies but not more than necessary. Also, $N$ would capture the actual noise distribution if the sample is large enough.
Again, it is not possible to deterministically find $P,N$, but we can find upper bounds. Furthermore, this provides a way to compare approximations of an unknown function given a noisy sample of points. If we have 2 polynomials, one with low degree and simple coefficients that fits close enough, and the other with very high degree and complicated coefficients but passing through all the points at the sample resolution, you can be sure that the low degree polynomial will have lower complexity modulo noise. Likewise, you can try as many approximations as you like and simply choose the one that has the lowest complexity modulo noise.
This also allows you to use your intuition to guide your attempts. For real-world measurements, they tend to suffer from Gaussian noise, so you can try $N$ being a normal random variable with various variances (the mean is already captured by $P$).
It should be impossible to over-fit using this method, which is the crucial property that you are looking for.
Best Answer
When the scaling factor augments $x$ (as in $f(nx)$ as opposed to $nf(x)$), you simply need to divide each $x$ by $n$ and keep the corresponding $y$ values the same. Essentially, the graph is compressed. If $0<|n|<1$, the graph gets stretched. If $|n|>1$, the graph gets compressed. If $n<0$, in addition to being compressed or stretched, the graph gets flipped horizontally. Particularly in your case:
\begin{array}{|c|c|} \hline x&y\\ \hline -20&7\\ \hline -5&-2\\ \hline 0&3\\ \hline 15&-4\\ \hline 30&5\\ \hline \end{array}