
<p class="has-drop-cap wp-block-paragraph">1 Ett av landets allra längsta travlopp. Ikväll är det dags för Smålandsstayern på Vaggerydstravet med grunddistansen 3.654 meter!</p>



<p class="wp-block-paragraph">Smålandsstayern hette tidigare Max Flukts lopp som en hyllning till en av banans största stjärnor genom tiderna. I regi Kent Knutsson gjorde Spotlite Lobell-sonen blott 15 starter, men vilka insatser han bjöd på! Framför allt stack de dubbla triumferna i Harper Hanovers lopp, 2005 och 2006 ut, i karriären som inbringade 1.812.000 kronor. När Max Flukt vann Harpers 2006 satte han dessutom nytt världsrekord, 1.13,8 över 3.160 meter.</p>



<p class="wp-block-paragraph">2017 fick loppet namnet Smålandsstayern och då blev också distansen ett halvvarv längre. I år får loppet ett rejält lyft prissummemässigt, då förstapriset är av gulddivisionsklass: 150.000 kronor jämfört med 75.000 kronor 2022.</p>



<p class="wp-block-paragraph">Fredrik Persson har vunnit tre av de senaste sex åren och dubble vinnaren <strong>Hurricane Silas</strong> (e. Maharajah) finns med i årets upplaga som håller hög klass. Bland annat syns Orebro Intn’l-vinnaren <strong>Versace Face</strong> (e. Joke Face) och fjolårets Derbytrea <strong>Edibear</strong> (e. Make It Happen) bland de 14 deltagarna i loppet.</p>



<h2 class="wp-block-heading">Senaste vinnarna av Smålandsstayern</h2>



<p class="wp-block-paragraph"><em>År, häst (far) – Kusk (tränare) – Tid/distans</em></p>



<ul class="wp-block-list">
<li>2017 <strong>Alfas da Vinci</strong> (e. Orlando Vici) – Joakim Lövgren – 1.14,9/3.700</li>



<li>2018 <strong>Elliot Coger</strong> (e. Enjoy Lavec) – Fredrik Persson – 1.16,7/3.680</li>



<li>2019 <strong>Explosive Merlot</strong> (e. Explosive Matter) – Robert Bergh – 1.16,9/3.680</li>



<li>2020 <strong>Hurricane Silas</strong> (e. Maharajah) – Fredrik Persson – 1.16,8/3.640</li>



<li>2021 <strong>Hurricane Silas </strong>(e. Maharajah) – Ulf Ohlsson (Fredrik Persson) – 1.14,8/3.680</li>



<li>2022 <strong>Fighter Simoni </strong>(e. Orlando Vici) – Carl Johan Jepson (Maria Törnqvist) – 1.17,0/3.674</li>
</ul>



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



<p class="has-drop-cap wp-block-paragraph">2 Förutom Smålandsstayern utgörs onsdagskvällens V86-omgång i Vaggeryd (första start 18.20) av fyra STL-klasser, två flerklasslopp med voltstart (varav ett för fyraåringar), samt ett ungdomslopp. Samtliga med sexsiffrig segercheck.</p>



<p class="wp-block-paragraph">Just fyraåringsloppet över lång distans innehåller flera spännande namn och hästar fortsatt i början av sina karriärer. En av dem är rutinerade Åbytränaren Per Henriksens<strong> Make It Schermer </strong>(e. Propulsion), som är lika snabb som han är svårhanterlig. </p>



<p class="wp-block-paragraph">I början av april fick Henriksen hästen i stallet och efter andraplatsen i regidebuten blev det full pott i klass I-försöket i Eskilstuna i början av juni. Då slog valacken knockout på konkurrenterna när han via tredjespår första 800 meterna till dödens vann lätt på 1.10,9a/1.640 meter!<br>– <em>Han var lite lugnare inför loppet, men när vi kom upp bakom bilen tog han i igen, det var en brottningsmatch mellan oss båda</em>, sade segerkusken Rikard N Skoglund efter segerloppet.</p>



<p class="wp-block-paragraph">Ja, Henriksen har fått plocka fram all erfarenhet han skaffat sig under åren och hittat en lösning för att kunna träna Make It Schermer. Han har fäst en grind på en stege som sitter på en pickup. Henriksen kör själv bilen med tidtagarur i näven och en hästskötare kör hästen. Detta berättade Per Henriksen när Åbytravets Kristofer ”Fölet” Jakobsson gästade Henriksens träningscamp.</p>



<p class="wp-block-paragraph"><a href="https://abytravet.se/hort-och-hant/folet-hos-per-henriksen/" target="_blank" rel="noreferrer noopener">Kolla in besöket hos Henriksen här!</a></p>



<p class="wp-block-paragraph"><em>Det är jackpot på V86 med närmare fem miljoner kronor extra i åttarättspotten.</em></p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2023/06/28v86.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till Vaggeryds tävlingar.</a></p>



<p class="wp-block-paragraph"><em>Vill du spela V75 tillsammans med Sulkysport finns följande alternativ:</em></p>



<p class="wp-block-paragraph"><a rel="noreferrer noopener" href="https://www.atg.se/andelskungen/spel/206233_V86_2023-06-28_43_3" target="_blank">Sulkysport Lilla V86 – 15 andelar á 75 kr/styck</a></p>



<p class="wp-block-paragraph"><a rel="noreferrer noopener" href="https://www.atg.se/andelskungen/spel/206235_V86_2023-06-28_43_3" target="_blank">Sulkysport Stora V86 – 15 andelar á 250 kr/styck</a></p>



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



<p class="has-drop-cap wp-block-paragraph">3 Tvåa-tvåa-etta med galoppinslag på vägen var resultaten i våras för treåriga snackhästen <strong>Lannem Selma </strong>med den gyllene härstamningen Tekno Odin-<strong>Lannem Silje</strong>, men när hon skulle starta på Bergsåker för knappt tre veckor sedan bedömdes hon inte tävlingsmässig och ströks ur loppet.</p>



<p class="wp-block-paragraph">Nu ska stoet lämna Jan-Olov Persson och istället resa hem till ägaren och uppfödaren Ola M Skrugstad i Norge. Detta berättar norska Trav- og Galopp-Nytt.<br>– <em>Hon skötte sig inte i volten och exakt vad som hände vet jag inte. Nu är det min tur att träna</em>, säger Skrugstad till TGN.</p>



<p class="wp-block-paragraph">Lannem Selma är fortsatt upptagen på Perssons träningslista i väntan på att pappersarbetet för resan över gränsen ska bli klar. Kvalen till Kriteriestoet avgörs på Dannero den 6 augusti och Skrugstad har inte avskrivit möjligheten att vara med där. </p>



<p class="wp-block-paragraph">Lannem Selma har på sina tre starter sprungit in 52.500 kronor. Vid segern i Bollnäs i april noterade hon sitt rekord 1.32,2am. </p>



<p class="wp-block-paragraph">Storasyster Lannem Stella vann Kriteriestoet ifjol, men är segerlös i årets fyra starter. På söndag startar hon i ett fyraåringslopp för ston på Hagmyren som genrep inför Derbystokvalen i Östersund den 20 juli.</p>



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



<p class="has-drop-cap wp-block-paragraph">4 Fyra av de 15 deltagarna i eftermiddagens Prix de Beaumont de Lomagne (€31.000) i franska Vichy (första start 16.08) är svenskfödda.<br>Philippe Daugeards<strong> Staro Mojito </strong>(e. Make it Happen) och Jo Corbanies <strong>Mad Princess</strong> (e. Nu Pagadi) har startat på fransk mark tidigare och nu sällskapas de av <strong>Dante Godiva</strong> (e. Up and Quick) samt<strong> Silver Bullit </strong>(e. Orlando Vici) vilka gör debut för David Cinier samt tidigare nämnde Jo Corbanie.</p>



<p class="wp-block-paragraph">Blågult intresse finns även i Prix de Rochefort Montagne (€25.000) på samma bana då Tomas Malmqvists <strong>Junior du Vallon</strong> (e. Coktail Jet) och Björn Goops <strong>Jack l&#8217;Eventreur</strong> (e. Oardo) finns bland de elva deltagarna.</p>



<figure class="wp-block-image aligncenter size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2020/06/dantegodiva-617x333.jpg" alt="" class="wp-image-95361"/><figcaption class="wp-element-caption">Dante Godiva ska göra debut på fransk mark. Foto Simon Hagen/Sulkysport</figcaption></figure>



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



<p class="has-drop-cap wp-block-paragraph">5<strong>Garth Vader </strong>(e. Ken Warkentin) gick i lördagens segrande ur striden i Nils Arne Eggens Äreslopp på Varig Orkla Arena och belönades utöver segerchecken på 250.000 norska kronor även med en direktplats i Åby Stora Pris.<br>Den chansen avser dock inte kretsen kring hästen att nyttja.<br>– Vi har sagt nej till Åby. Vad som blir nästa start för Garth Vader är inte bestämt, men det kan bli ett kval till Silverdivisonen i Årjäng, <a rel="noreferrer noopener" href="https://tgn.no/artikkel/nei-fra-brenne-velger-heller-biri/" target="_blank">säger Jens Kristian Brenne till norska TGN.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">6 Från start på Vincennes 1.950 meter långa bankropp till Arvikas 800 metersoval!<br>Den resan gör <strong>Dexter Chatho</strong> (e. Un Amour d&#8217;Haufor) när han nu är redo för sin första start på svensk mark.<br>Håkan B och Gustav Johanssons tioåriga nyförvärv från Frankrike ska nämligen starta i Arvikas Jubileumslopp på måndag och han gör det från spår åtta över 1.700 meter autostart i jakt på segerchecken á 70.000 kronor.</p>



<p class="wp-block-paragraph"><strong>Startlista Arvikas Jubileumslopp</strong><br><em>1.700 meter autostart</em></p>



<ol class="wp-block-list">
<li>Souvenir d&#8217;Inverne – Janne Svart</li>



<li>Oxidizer – Carl Johan Jepson</li>



<li>Vitro Diablo – Erik Killingmo</li>



<li>Park View – Kim Eriksson</li>



<li>Final Dream – Mikael J Andersson</li>



<li>Test Drive – Petter Karlsson</li>



<li>Tjacko Zaz – Oskar J Andersson</li>



<li>Dexter Chatho – Gustav Johansson</li>



<li>Ajlexes Cubano – Magnus Jakobsson</li>



<li>Always On Time – Dagfinn Aarum</li>
</ol>



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



<p class="has-drop-cap wp-block-paragraph">7 Ett svenskköp kan rapporteras om från Vente d’Ete i Cabourg igår. Rikard Björling lade beslag på ett ettårigt sto och för <strong>Meta Bourbon</strong> (e. Saxo de Vandel-Fizz Gentille) betalade han 3.000 euro. Stoet är undan <strong>Fizz Gentille</strong> (e. Atlas de Joudes), 1.15,8/€23.090, och moderns första avkomma. På tävlingsbanan blev det två triumfer för Fizz Gentille i Agon-Coutainville och Avranches, värderade till 5.400 respektive 5.850 euro.</p>



<p class="wp-block-paragraph">Fizz Gentille är undan <strong>Night Augenais</strong> (e. Capriccio), 1.14,3/€241.940, vilken också lämnat <strong>Extra Gentille </strong>(e. Rieussec), 1.14,0/€44.590. Själv ingår Night Augenais i samma syskonskara som<strong> Gatsby</strong> (e. Viking’s Way), 1.12.6/€461.421, som vann 21 lopp på 111 starter och däribland Prix de Brest.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/06/fzpn3kiwiae89cx-617x411.jpg" alt="" class="wp-image-463765"/><figcaption class="wp-element-caption">Jealousy Love. Foto: Mélissa Delalande</figcaption></figure>



<p class="wp-block-paragraph">Auktionens dyraste travare blev <strong>Jealousy Love </strong>(e. Scipion du Goutier-Song of Love), 1.14,3am/€27.915. En anonym köpare lade upp 60.000 euro för det Jean-Pierre Dubois-ägda fyraåriga stoet. Jealousy Love vann i sin näst senaste start i Vichy och det är hennes enda seger på 16 starter.</p>



<p class="wp-block-paragraph">Ostartade modern <strong>Song of Love</strong> (e. Coktail Jet-Guilty of Love) har också lämnat <strong>I Still Loving You </strong>(e. Prince Gede), 1.13,1/€150.250, och <strong>Chanson d’Amour </strong>(e. Sam Bourbon), 1.13,9/€110.820. Själv är Song of Love helsyster med flerfaldige championhingsten<strong> Love You</strong> (€1.416.527) och i samma familj ingår <strong>Nice Love </strong>(€435.550), <strong>Repeat Love</strong> (€290.680), <strong>In Dix Huit </strong>(€120.882) och <strong>Perhaps Love </strong>(€119.509).</p>



<p class="wp-block-paragraph">Av 150 utbjudna hästar såldes 99 för totalt 1.430.000 euro och snittpriset uppgick till 14.444 euro. Vid fjolårets auktion landade medelpriset på 13.690 euro. Det kan också noteras att Robert Bergh-tränade duon <strong>Ad Hoc </strong>och <strong>Global Lover</strong> var strukna från auktionen.</p>



<p class="wp-block-paragraph"><a href="https://www.arqana-trot.com/resultats/vente-d-ete-2023/198" target="_blank" rel="noreferrer noopener">Här hittar ni alla resultaten från Vente d’Ete i Cabourg.</a></p>

Fokustema
Morgonsvepet
Läs senare
Starkast i Småland?
Om onsdagens styrkeprov i Småland, toppstammat kallblod som byter regi samt en fransos som går från start på Vincennes till Arvika går bland annat att läsa i veckans tredje morgonsvep.
