
<p class="has-drop-cap wp-block-paragraph">1 ATG bildades den 9 maj 1973, medan den första V65-omgången hölls nästan prick på dagen för 50 år sedan på Solvalla. Idag säger Sulkysport ett stort grattis till ATG. Då hette rikstotospelet V65 – idag V75.</p>



<p class="wp-block-paragraph">– Jag tror inte att det var enskild faktor som var orsaken till framgången för V65 och rikstoton. Det var istället en kombination av lyckliga omständigheter och flera lyckade beslut i uppläggning och genomförande som låg bakom, skriver ATG:s första verkställande direktör Gert Lindberg i boken ”Travet i våra hjärtan.”</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/08/skarmavbild20240815kl.08.19.37-617x429.jpg" alt="" class="wp-image-622190"/><figcaption class="wp-element-caption">ATG:s förste vd Gert Lindberg, Rodetto, Hans-Owe Sundberg och jordbruksminister Ingemund Bengtsson. Faksimil från boken ”Travet i våra hjärtan.”</figcaption></figure>



<p class="wp-block-paragraph">V5 förvandlades till V65 och idag är det V75 och sju lopp på kupongen. Att V65 blev en succé berodde mycket på att det blev riksomtäckande och flyttades mellan landets banor vecka för vecka istället för att Solvalla ensam skulle vara arrangerande bana.</p>



<p class="wp-block-paragraph">ATG gjorde också ett smart drag och skickade ut gratisprogram (numera skrotat) till alla landets alla postkontor. På den tiden var Postverket huvudombud för V65.</p>



<p class="wp-block-paragraph">Idag arrangerar Gävle-travet jubileumsomgången för rikstoton. Tänk vad tiden har runnit iväg…det är ett halvt sekel sedan de sex första vinnarna sågs från Solvalla den 18 augusti 1974:</p>



<ul class="wp-block-list">
<li>V65-1: <strong>Rodetto</strong>-Hans-Owe Sundberg</li>



<li>V65-2: <strong>Master Qui</strong>-Hans Barkevall</li>



<li>V65-3: <strong>Caballero</strong>-Olle Goop</li>



<li>V65-4: <strong>Scottish Heath</strong>-Hans Svensson</li>



<li>V65-5: <strong>Air France</strong>-Lennart Karlsson</li>



<li>V65-6: <strong>Scott Eden</strong>-Sören Nordin</li>
</ul>



<p class="has-text-align-center wp-block-paragraph">***</p>



<p class="has-drop-cap wp-block-paragraph">2 I eftermiddag är <strong>Gävletravet</strong> (första start 14.45) i blickfånget med V75 på agendan, som dessutom kryddas med en jackpot på 40 miljoner kronor. Förutom de korta E3-finalerna är Gävle Stora Pris, som körts sedan 1942, huvudnumret för dagen över 2.640 meter autostart. Lite trist att förhandsfavoriten <strong>Kentucky River</strong> (e. Father Patrick) blivit struken, men det öppnar upp loppet ännu mer.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/06/staromackcrowernsd230621adamstromstalltz-617x404.jpg" alt="" class="wp-image-461202"/><figcaption class="wp-element-caption">Staro Mack Growe segerdefilerar för Rikard N Skoglund. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p class="wp-block-paragraph"><strong>Staro Mack Crowe</strong> (e. Bold Eagle) gjorde debut i Mattias Djuses regi i senaste starten och slutade trea med mersmak bakom <strong>Bedazzled Sox</strong> (e. Brillantissime), som i onsdags hemförde Margareta Wallenius-Klebergs Pokal.</p>



<p class="wp-block-paragraph">Förra året vann Oscar Berglund-tränade <strong>Dwayne Zet</strong> (e.Muscle Massive) Gävle Stora Pris med Magnus A Djuse som kusk.</p>



<p class="has-text-align-center wp-block-paragraph">***</p>



<p class="has-drop-cap wp-block-paragraph">3 En som står över V75-tävlingarna på Gävle är Bergsåkerstränaren Öystein Tjomsland som istället beger sig till Örnsköldsvik för att vara med på <strong>Solängets</strong> V65-tävlingar (första start 18.30). Med sig i transporten har han sex hästar från stallet och han lär bli hårt betrodd med de flesta av dem han kommer med.</p>



<p class="wp-block-paragraph">På förhand är de bästa möjligheterna <strong>Quick Håleryd</strong> (e. Father Patrick) och kallblodet<strong> Skeie Balder</strong> (e. Tekno Odin).</p>



<p class="wp-block-paragraph">Först ut på förmiddagen är <strong>Tingsryd</strong> (första start 11.10) där det är breddlopp som står på programmet. En som jagar startpoäng är Preben Söviks femåring <strong>Just Perfect Sisu</strong> (e. Brilliantssime) som har 1,1 miljoner kronor på kontot efter sin andraplats i det norska Derbyt förra året. Därefter har det mesta gått snett. </p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2024/08/240817.pdf">Här är startlistorna till Tingsryd, Gävle och Solängets tävlingar.</a></p>



<p class="has-text-align-center wp-block-paragraph">***</p>



<p class="has-drop-cap wp-block-paragraph">4 Fyra dagars tävlande och auktion. Det är hektiska dagar på Mariendorf-banan i Berlin. Idag avhålls en av meetingets höjdpunkter och det handlar om Tyskt Stoderby (€98.984) för 2020-kullen och där Stefan Persson gästkuskar bakom Wolfgang Nimczyk-tränade <strong>Exmes As</strong> (e. Crazed), vilken slutade tvåa i sitt försök för Michael Nimczyk bakom <a href="https://sulkysport.se/nimczyk-dominerade-i-berlin/" data-type="link" data-id="https://sulkysport.se/nimczyk-dominerade-i-berlin/" target="_blank" rel="noreferrer noopener">Speedrise Lady S</a>.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/02/stefanpersson2-617x333.jpg" alt="" class="wp-image-410268"/><figcaption class="wp-element-caption">Stefan Persson gästspelar bakom Exmes As i Tyskt Stoderby idag. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="wp-block-paragraph"><strong>Tyskt Stoderby</strong> (€98.984)<br>Fyraåriga tyskfödda ston.<br><strong>Priser: </strong>46.992-23.246-11.678-7.619-4.949-2.000-1.500-1.000 euro.<br><em>1.900 meter, autostart.</em></p>



<p class="wp-block-paragraph"><strong>Namn (far) – Körsven</strong></p>



<ol class="wp-block-list">
<li><strong>Croisette </strong>(e. Muscle Hill) – Thorsten Tietz</li>



<li><strong>Nightlife Greenwood </strong>(e. Brillantissime) – Jaap van Rijn</li>



<li><strong>Naikey</strong> (e. Robert Bi) – Michael Nimczyk</li>



<li><strong>Speedrise Lady S</strong> (e. Walner) – Michel Rothengatter</li>



<li><strong>Cosmea</strong> (e. S.J.’s Caviar) – Robbin Bot</li>



<li><strong>Exmes As</strong> (e. Crazed) – Stefan Persson</li>



<li><strong>Whispering Angel </strong>(e. Southwind Frank) – Josef Franzl</li>



<li><strong>New Born Steel </strong>(e. Ufo Kievitshof) – Dion Tesselaar</li>



<li><strong>Noble Rush Flevo </strong>(e. Muscle Mass) – Thomas Panschow</li>



<li><strong>Time Matters</strong> (e. Broadway Hall) – Jeffrey Mieras</li>



<li><strong>Habibii</strong> (e. Villiam) – Marciano Hauber</li>



<li><strong>Lake Louise </strong>(e. Tobin Kronos) – Jens Bergmann</li>
</ol>



<p class="has-text-align-center wp-block-paragraph">***</p>



<p class="has-drop-cap wp-block-paragraph">5 Stefan Persson är inte ensam svensk i Berlin. I finalen i Super Trot Cup (€70.000) för äldre travare startar Johan Untersteiners duo <strong>Global Delayed</strong> (e. S.J.’s Caviar) och <strong>Call Me Gleipner </strong>(e. Explosive Matter), som körs av Stefan Persson respektive Peter Untersteiner. Adrian Kolgjini deltar med <strong>Swish the Cash</strong> (e. Ready Cash) och sedan gästspelar Jörgen Sjunnesson bakom Torben Hovgaards <strong>Gautut Gardenia</strong> (e. Racer Bourbon).</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/05/jonathancarrekmfoto-617x333.jpg" alt="" class="wp-image-445359"/><figcaption class="wp-element-caption">Jonathan Carré. Foto Kjeld Mikkelsen/KM FOTO</figcaption></figure>



<p class="wp-block-paragraph">Sveriges montékung Jonathan Carré dyker också upp i Berlin och rider Henk Grifs <strong>Corps et Ame </strong>(e. Jag de Bellouet) i Monté-Derbyt (€20.000) med 10.000 euro till vinnaren i ett lopp för alla åldrar.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2024/08/berlin1782024.pdf" data-type="link" data-id="https://sulkysport.se/wp-content/uploads/2024/08/berlin1782024.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till Mariendorfs tävlingar.</a></p>



<p class="has-text-align-center wp-block-paragraph">***</p>



<p class="has-drop-cap wp-block-paragraph">6 Ikväll arrangeras den tyska Derby-auktionen på Mariendorf-banan i Berlin, men även på svensk mark säljs det hästar. </p>



<p class="wp-block-paragraph">På Travera bjuds 19 travare ut och treårige valacken <strong>Steady and Quick</strong> (e. Googoo Gaagaa-Steady Brodda), 1.14,3am/134.500 kr, har redan stuckit iväg i sexsiffrigt belopp och det är KB Capulus Horses som säljer hästen som är inkvalad till semifinalen i Breeders Crown senare i vinter och som tränas av Daniel Wäjersten.</p>



<p class="wp-block-paragraph"><a href="https://www.travera.nu/kopa-hast/" data-type="link" data-id="https://www.travera.nu/kopa-hast/" target="_blank" rel="noreferrer noopener">Här hittar ni hästarna som bjuds ut på kvällens Travera-auktion.</a></p>



<p class="has-text-align-center wp-block-paragraph">***</p>



<p class="has-drop-cap wp-block-paragraph">7 Högklassig travsport bjuder Pocono Downs på idag och det är inte bara VM-inbjudna och svenskfödda <a href="https://sulkysport.se/varlds-eller-svenskt-rekord/" data-type="link" data-id="https://sulkysport.se/varlds-eller-svenskt-rekord/" target="_blank" rel="noreferrer noopener">Jiggy Jog </a>(e. Walner) som startar i Wilkes-Barre.</p>



<p class="wp-block-paragraph">Högsta prissumman delas ut i den högsta divisionen av tre i Earl Beal Jr. Memorial ($300.000) och där startar tre svensktränade travare. Åke Svanstedts Hambletonian-trea <strong>Amazing Catch</strong> (e. Walner) körs av Dexter Dunn, medan Åke hoppar upp bakom <strong>Situationship</strong> (e. Chapter Seven) och Marcus Melander lånar ut tömmarna till Scott Zeron bakom <strong>Security Protected </strong>(e. Father Patrick).</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/08/amazingcatchash240703adamstromstalltz-617x362.jpg" alt="" class="wp-image-622221"/><figcaption class="wp-element-caption">Åke Svanstedt värmer upp Amazing Catch inför finalen i Hambletonian Stakes. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p class="wp-block-paragraph">Motståndet håller hög klass med bland andra fyran och femman i Hambletonian Stakes, <strong>Sig Sauer </strong>(e. Muscle Hill) respektive <strong>T C I </strong>(e. Cantab Hall).</p>



<p class="wp-block-paragraph"><strong>Earl Beal Jr. Memorial </strong>($300.000)<br>Treåringar.<br><em>1.609 meter, autostart.</em></p>



<p class="wp-block-paragraph"><strong>Namn (far) – Körsven</strong></p>



<ol class="wp-block-list">
<li><strong>Spaaazano </strong>(e. Coraggioso) – Aaron Merriman</li>



<li><strong>Amazing Catch </strong>(e. Walner) – Dexter Dunn</li>



<li><strong>Sig Sauer</strong> (e. Muscle Hill) – Andrew McCarthy</li>



<li><strong>T C I </strong>(e. Cantab Hall) – David Miller</li>



<li><strong>Security Protected</strong> (e. Father Patrick) – Scott Zeron</li>



<li><strong>Situationship</strong> (e. Chapter Seven) – Åke Svanstedt</li>



<li><strong>Fly By </strong>(e. Chapter Seven) – Tony Alagna</li>



<li><strong>Gruesome Twosome</strong> (e. You Know You Do) – Daryl Bontrager</li>
</ol>



<p class="wp-block-paragraph"><a href="https://racing.ustrotting.com/goto.aspx?target=12,96324" data-type="link" data-id="https://racing.ustrotting.com/goto.aspx?target=12,96324" target="_blank" rel="noreferrer noopener">Här hittar du alla startlistorna till Pocono Downs tävlingar.</a></p>



<p class="wp-block-paragraph"><span style="caret-color: rgb(0, 0, 0); color: rgb(0, 0, 0); font-family: Helvetica; font-size: 12px; font-style: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: auto; text-align: start; text-indent: 0px; text-transform: none; white-space: normal; widows: auto; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration: none; display: inline !important; float: none;"></span></p>

Fokustema
Morgonsvepet
Läs senare
Hipp, hipp, hurra, ATG!
50 år sedan första rikstotoloppet avgjordes. Stefan Persson kör Tyskt Stoderby. Norsk Derby-tvåa jagar startpoäng i Tingsryd. Stortävlingar på Pocono Downs och vem vinner Gävle Stora Pris?
Det är några av Sulkysports ”Sju nyheter vid sju.”
Det är några av Sulkysports ”Sju nyheter vid sju.”
