
<p class="has-drop-cap">1 Rubriken av dagens morgonsvep kan tyckas kaxig, men det är sannerligen inte till att sticka ut hakan och lova att det blir världsrekord i kvällens Diamantstoförsök namngivet Lill Mavils lopp på Åmålstravet (första start 18.30).</p>



<p>Det nuvarande världsrekordet för femåriga och äldre ston i stayerlopp på 800 metersbana som startas med voltstart innehar <strong>Wild Jesse </strong>(e. Tres Solide L.) på tiden 1.21,3 satt på Bornholm. För fyraåriga ston är noteringen som ska slås 1.22,2 vilket <strong>What A Babe</strong> (e. Ens Snapshot) likaså satte vid start i Bornholm.<br>– Vi har massa världsrekord som satts här i Åmål sedan tidigare då vi har en 800 metersbana och lopp som startas med voltstart och nu kommer ytterligare ett slås, har Göran Svensson på Åmålstravets sekretariat tidigare sagt till Sulkysport.</p>


<div class="factbox full ">
<div class="insidefactbox">
<div class="overflow">
<div class="height">
<div class="padding">
<div class="factvinjett">Fakta</div>
<h3 class="title">
									Visste du att&#8230;								</h3>
<div class="content">
<p>…det just nu finns 14 världsrekord satte på Åmålstravet enligt Travrondens världsrekord-tabeller.<br />Det snabbaste av dem innehar <strong>Wellino Avenue</strong> (e. Wellino Boko) då han vann på 1.13,5/2.100 meter voltstart den 16 juni år 2019.<br />Noteringen innebar nytt världsrekord för äldre hingstar och valacker i medeldistanslopp på 800 metersbana med startmetoden voltstart.</p>
</p></div>
</p></div>
</p></div>
</p></div>
</p></div>
</p></div>



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



<p class="has-drop-cap">2 På Åmålstravet avgörs fullskaliga STL-tävlingar. Utöver nämnda Diamantstoförsök avgörs även Klass II, Klass I, Brons-, Silver- samt Gulddivisionen och Kallblodsdivisionen och inom V86-spelet körs därtill ett flerklasslopp med 100.000 kronor till vinnaren.</p>



<p>Kvalitén på tävlingarna är blandad och flera av loppen direkt ihåliga vilket säkerligen beror på en kombination av täta storloppshelger på såväl svensk som norsk mark samt det faktum att många drar sig för att anmäla till en 800 metersbana där startspåren många gånger kan vara direkt avgörande.</p>



<p>Dalslandsbanans klassiker Ändå Något har avgjorts sedan år 1970 i olika format, men aldrig haft så högt förstapris som årets upplaga.<br>Gulddivisionsloppet belönar vinnaren med 150.000 kronor och Lars I Nilsson är en av de som prövar lyckan i loppet med sin startraket <strong>Sweetman</strong> (e. Gift Kronos).<br>Banrekordet i Åmål lyder 1.11,2a/1.680 meter satt av <strong>Cool Keeper</strong> år 2017.</p>



<p>Vad Jägersrotränaren säger om den hästen samt de övriga tre springarna han låter göra den 47 mil långa resan norröver med kan du läsa här.</p>



<p><em>Vill du spela V86 tillsammans med oss på Sulkysport finns det som vanligt två alternativ:</em></p>



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



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



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



<p class="has-drop-cap">3 Dagens högst doterade lopp på europeisk mark avgörs i franska Laval (första start 14.23).<br>Under den tidiga kvällen görs årets sjätte etapp av löpningsserien Grand National du Trot (€90.000) och där startar Tomas Malmqvists <strong>Howdy Partner</strong> (e. Repeat Love) från grunddistansen 2.850 meter.<br>Den 8 mars vann sexåringen årets första GNT-lopp i Amiens tillsammans med Franck Nivard och det är även han som sitter i sulkyn denna gång när det står 40.500 euro på spel till vinnaren.<br>Bland konkurrenterna utmärker sig Sébastien Guaratos<strong> Horace du Goutier </strong>(e. Ready Cash) som även han vunnit GNT-lopp under året samt Christian Bigeons<strong> Goeland d&#8217;Haufor</strong> (e. Voltigeur de Myrt) som besegrade <strong>Oracle Tile</strong> (e. Ready Cash) på Vincennes i början av maj.</p>



<figure class="wp-block-image aligncenter size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/03/00226133012scoopdyga-617x411.jpg" alt="" class="wp-image-417476"/><figcaption class="wp-element-caption">Tomas Malmqvists Howdy Partner vid GNT-segern i Amiens den 8 mars. Foto Scoopdyga.com</figcaption></figure>



<p>I montéloppet Prix Henri Desmontils (€39.000) ska Christoffer Eriksson-tränade <strong>Self Explosive </strong>(e. Explosive Matter) försöka bärga sin femte sadelseger på fransk mark detta år. Alexandre Abrivard rider åttaåringen som strider mot Tomas Malmqvists <strong>Devs Definitif </strong>(e. Infinitif).</p>



<p>Malmqvist startar även<strong> Jorgio de Vandel </strong>(e. Ready Cash) i fyraåringsloppet Prix Barons Guy Et Jacques de Meynard (€27.000) där även Björn Goop-tränade <strong>Jack l&#8217;Eventreur</strong> (e. Oardo) finns med.<br>Färjestadtränaren har ytterligare en starthäst i Laval då <strong>Icarus Bourbon</strong> (e. Prodigious) ska försöka bärga första årssegern i Prix V and B Laval (€27.000) tillsammans med Yoann Lebourgeois.</p>



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



<p class="has-drop-cap">4 Onsdagens tävlingsutbud på svensk mark kompletteras med nio lopp i Gävle (första start 15.45) där inget lopp körs med mer än 35.000 kronor i förstapris, men det har inte avskräckt stortränare från att anmäla.<br>Daniel Redén sänder en duo till Gästrikland, Paul Hagoort likaså och Alessandro Gocciadoro låter Maharajah-dottern <strong>Dacia del Ronco</strong> göra debut på svensk mark i ett stolopp.</p>



<p>Av Redéns bidrag sticker stamtavlan på <strong>Epic Kronos</strong> (e. Muscle Hill) ut. Treåringens franskfödda mor <strong>Firefly</strong> (e. Ready Cash) 1.13,4am/341.769 kr gick segerlös genom karriärens 16 starter, men får anses vara blåblodigt stammad då henne ostartade mor <strong>Topaze Bourbon</strong> (e. Love You) är syster till såväl <strong>Mara Bourbon </strong>(e. And Arifant) 1.10,4/€1.657.405 och <strong>Qualita Bourbon</strong> (e. Love You) 1.12,3/€1.538.050 som till avelshingstarna <strong>Sam Bourbon</strong> (e. Goetmals Wood) 1.11,6/€373.430 och <strong>Racer Bourbon</strong> (e. Love You) 1.15,0/€38.930.</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2023/06/230607.pdf" target="_blank" rel="noreferrer noopener">Här kan du ta del av onsdagens startlistor till tävlingarna i Gävle och Åmål.</a></p>



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



<p class="has-drop-cap">5 Dubbelmiljonären <strong>Vagabond Bi </strong>(e. Varenne) avslutar sin tävlingskarriär. Nioåringen anslöt som femåring till David Perssons stall och blev snabbt en klassklättrare som tog sig hela vägen upp till eliten.<br>Sju gånger vann valacken lopp med sexsiffrigt förstapris och de två mest penningstinna fullträffarna togs under år 2020 då hästen vann såväl Bronsdivisionens final som Walter Lundbergs Memorial inom loppet av två månader.<br>Däremot hann hästen även med en start i Grupp I-klassade Sundsvall Open Trot och kom undan med hedern i behåll som femma.<br>– <em>Vi har inte riktigt fått tillbaka hästen efter skada. Han tar loppen hårt hela tiden och reagerar i kropp och ben efter varje lopp så då blir det naturligt att avsluta karriären</em>, säger David Persson.</p>



<p>Den italienskfödda hästen gör därmed bokslut med 17 segrar på 87 starter och 2.173.029 kronor i intjänade prispengar.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2020/09/vagabondbipris-617x333.jpg" alt="" class="wp-image-112992"/><figcaption class="wp-element-caption">Vagabond Bi tillsammans med David Persson efter segern i Walter Lundbergs Memorial år 2020. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



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



<p class="has-drop-cap">6<strong>Ava di Alessia</strong> (e. Express Duo), <strong>Carla Combo</strong> (e. Maharajah) och <strong>Truthisoutthere</strong> (e. Zola Boko) lade beslag på topplaceringarna i finska Stokriteriet under fjolåret.<br>Idag möts den trion på nytt när det är dags för Tammachampion (€22.000) att avgöras på Vermobanan i Helsingfors.</p>



<p>Extra noterbart är att de tre senaste årens vinnare av Tammachampion Mascate Match, Magical Princess samt Dusktodawn Boogie därefter gått vidare och även vunnit Finskt Travderby.</p>



<p><strong>Startlista</strong><br><em>2.120 meter autostart, förstapris: 10.000 euro</em></p>



<ol class="wp-block-list">
<li>Ivory Susanne (e. Jontte Boy) – Tuomas Korvenoja</li>



<li>Carla Combo (e. Maharajah) – Janne Korpi (Pekka Korpi)</li>



<li>Make It Up (e. Make it Happen) – Olli Koivunen (Harri Koivunen)</li>



<li>Dorea Frido (e. Muscle Hill) – Ari Moilanen (Markku Nieminen)</li>



<li>Callela Ladybird (e. Quite Easy U.S.) – Santtu Raitala (Markku Nieminen)</li>



<li>Second Act (e. Quite Easy U.S.) – Tommi Kylliäinen</li>



<li>Thetruthisoutthere (e. Zola Boko) – Juha Utala (Kari Savolainen)</li>



<li>Inside the Fire (e. Brad De Veluwe) – Esa Holopainen (Harri Konttinen)</li>



<li>Vicky Savoy (e. Orlando Vici) – Antti Teivanen (Ari Viander)</li>



<li>Ava di Alessio (e. Express Duo) – Hannu Torvinen (Hannu-Pekka Korpi)</li>



<li>Mighty Real (e. Young Angus Kemp) – Jeroen van Craen</li>
</ol>



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



<p class="has-drop-cap">7 Klockan 09.00 denna onsdag går startanmälan ut till måndagens E3-kval som avgörs på Färjestad.<br>Vid morgonsvepets publicering var 34 hästar anmälda i klassen för hingstar och valacker och 40 i klassen för ston.</p>



<p>E3 har satt ett tak på maximalt 60 anmälda per klass och inget försök ska avgöras med fler än tio deltagare.</p>



<p>I &#8221;pojkarnas&#8221; avdelning kommer fjolårets vinnare av Svensk Uppfödningslöpning göra årsdebut.<br>Det handlar om Tomas Malmqvists <strong>Fiftyfour</strong> (e. Fourth Dimension) som kommer bli toppseedad ihop med Breeers Course-finalvinnaren <strong>Epsom As </strong>(e. Muscle Mass), men här går det även notera att Alessandro Gocciadoros supertalang <strong>Expo Wise As</strong> (e. Ready Cash) som raderade ut Going Kronos svenska rekord i Gävle den 20 maj är anmäld.</p>



<p>I stoklassen är fjolårets tvåa i Svensk Uppfödningslöpning <strong>Frustration</strong> (e. Fourth Dimension) den som tjänat mest prispengar följd av Stefan P Petterssons <strong>Kitty Hawk </strong>(e. Fourth Dimension).<br>Hon fick ge vika i sista steget i finalen av Breeders Course för treåriga ston gentemot Alessandro Gocciadoros <strong>Esmeralda Bez</strong> (e. Maharajah) och även trean Eteria (e. Tactical Landing) samt fyran<strong> Esperia Font</strong> (e. Face Time Bourbon) från samma lopp är anmälda till E3-kvalen.</p>



<p>Finalerna avgörs på Bergsåker lördag den 1 juli med en miljon kronor i förstapris.</p>

Fokustema
Morgonsvepet
Läs senare
Ikväll slås världsrekord
Om dagens världsrekordförsök i Åmål, Tomas Malmqvists jakt på storloppstriumf i Laval samt att en Gulddivisionshäst avslutar sin tävlingskarriär är några av de ämnen som berörs i dagens morgonsvep.
