
<p class="has-drop-cap">1 Björn Goop ropade för hästägares räkning in det dyraste sto som någonsin sålts på en svensk auktion när klubban föll på 3,1 miljoner kronor efter en häftig budgivning på Sweden International Yearling Sale på Solvalla sommaren 2021. Hästen det handlade om var <strong>Eyewink Kronos</strong> (e. Muscle Hill-Oyster Kronos), som bjöds ut av Winged Lion Breeding AB i Bjärred.</p>



<p>Köpare var det franska travförbundets ordförande Jean-Pierre Barjon, som förra våren satte stoet i träning hos Timo Nurmos. Ikväll i Lindesberg är det dags för tävlingsdebut för stoet, som kvalade på Solvalla för tre veckor sedan på 1.17,2/2.140 meter tillsammans med Jorma Kontio. Blott sex hästar står för motståndet i nolloppet.</p>



<p>Eyewink Kronos är undan italienskan <strong>Oyster Kronos</strong> (e. Conway Hall-Ms Vic), 1.10,4ak/1.753.063 kr, som tävlade för Lutfi Kolgjini och finalvann Stosprintern i Halmstad.</p>



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



<p class="has-drop-cap">2 Två sommarbanor pockar på uppmärksamheten på svensk mark denna fredagskväll, när Tingsryd (första start 18.20) och Lindesberg (start 18.30) delar på expresstravet.</p>



<p>Snabbloppet i Lindesberg ser två spännande ungdomar mot äldre konkurrenter. Fyraåriga, franska stoet <strong>Joyful Diva</strong> (e. Sam Bourbon) anlände till Åbytränaren Evelina Månsson förra veckan med svaga resultat i år bakom sig, men desto bättre treåringsmeriter där hon inledde säsongen som nybliven treåring med karriärens enda seger i Prix de Maisons-Laffitte (€50.000) på Vincennes veckan före Prix d’Amérique. Jarmo Niskanen tränade stoet på fransk mark där hon gjort 23 starter (1-5-2) och sprungit in 149.860 euro.</p>



<figure class="wp-block-image aligncenter size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2022/01/prixmaisonslafitte2-617x377.jpg" alt="" class="wp-image-261485"/><figcaption class="wp-element-caption">Joyful Diva är redo att göra sin första start på svensk mark. Foto: Gerard Forni</figcaption></figure>



<p>Ett annat oskrivet kort är Paul Hagoorts femåring <strong>Love You Too </strong>(e. Love You), som för två år sedan vann Breeders Course-finalen på Solvalla och 1.000.000 kronor på Elitloppsdagen. Han tog också bronsplatsen i finalen över kort distans senare den sommaren, men annars har det varit tunnsått med framgångar. Med ett lopp i kroppen är femåringen tillbaka på svensk mark och möter förutom Joyful Diva hästar som <strong>Criterion</strong> (e. Jocose) och <strong>Dark Roadster</strong> (e. Spurt Photo Kosmos).</p>



<p>På milebanan i Tingsryd plockar Johan Untersteiner ut obesegrade treåringen <strong>Steady King</strong> (e. S.J.’s Caviar), som får pappa Peter i vagnen den här gången. Att Steady King funkar fint på milebana visade hästen när han i livets andra start segrade på 1.12,4ak i Tingsryd.</p>



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



<p class="has-drop-cap">3 När Lycksele (start 12.20) avslutar sitt tredagarsmeeting med dagens lunchtävlingar är det också dags att dela ut årets första banchampionat i Sverige. Förra året gick kusktiteln på sommarbanan till Ove A Lindqvist och inför årsfinalen idag har han en seger upp till John Östman som toppar med tre fullträffar.<br>Ove A Lindqvist delar andraplatsen i körsvensligan med Stefan Johansson, Jenny Engfors samt Malin Strinnlund och medan Östman kör i fyra lopp denna tävlingsdag så har Ove A sju chanser.</p>



<p>En intressant årsdebutant i Lycksele är Öystein Tjomslands åttaåring <strong>Våler Nikolai</strong> (e. Åsajerven) med drygt 2,6 miljoner på priskontot efter framför allt starka fyra- fem och sexåringssäsonger. Ifjol gick det tyngre och hingsten blev segerlös i sju starter. Nu gör han första starten på nio månader och ska jaga från 80 meters tillägg i Lars Matsons Minne.</p>



<p>Snabbloppet för varmblod är en spårtrappa, där bland annat veteranen Thule Jonssons <strong>Rossi Palema </strong>(e. Symphonic Hanover) dyker upp bakom bilen tillsammans med John Östman.</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2023/07/230707.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till fredagens tävlingar.</a></p>



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



<p class="has-drop-cap">4 Jörgen Sjunnesson är ensam svensk om att vara representerad i dagens finaler av Grand Circle Treåringschampionat i Ålborg (första start 15.45).<br>I stoklassen får Jägersrokusken chansen bakom Magnus Ladegåds <strong>Iloveyou Butcher </strong>(e. Dominion Beach) och i klassen för hingstar och valacker kör han Impressive <strong>Hancock</strong> (e. Muscle Massive) åt Steen Juul.<br>Båda hästarna slutade fyra i sina respektive försökslopp och tillmäts begränsade möjligheter på förhand.</p>



<p><strong>Startlista Grand Circle Treåringschampionat, ston</strong><br><em>2.140 meter autostart, förstapris: 204.000 danska kronor</em></p>



<ol class="wp-block-list">
<li>Jamaica Gardenia (e. Ens Snapshot) – Jeppe Rask (Torben Hovgaard)</li>



<li>Just A Lady (e. S.J.&#8217;s Photo) – Bo Westergård</li>



<li>Isabella C N (e. Dream Vacation) – Nicklas Korfitsen (Bo Westergård)</li>



<li>Ivana Nordic (e. Explosive Matter) – Flemming Jensen (Bo Westergård)</li>



<li>Jacqueline Mosebo (e. Great Challenger) – Steen Juul</li>



<li>Jackie Wee (e. Maharajah) – Bent Svendsen</li>



<li>Iloveyou Butcher (e. Dominon Beach) – Jörgen Sjunnesson (Magnus Ladegård)</li>



<li>Iconic Sotto (e. Bird Parker) – Rene Kjaer (Morten Juul)</li>



<li>Jazz Laser (e. Bvlgari Peak) – Anders Pedersen</li>



<li>Joyce Aveve (e. Weingartner) – Birger Jörgensen (Peter Rasmussen)</li>



<li>Innocence (e. Gigant Neo) – Knud Mönster</li>



<li>Ivory (e. Broadway Hall) – Casper M Nielsen (Kaj Jensen)</li>
</ol>



<p><strong>Startlista Grand Circle Treåringschampionat, h/v</strong><br><em>2.140 meter autostart, förstapris: 204.000 danska kronor</em></p>



<ol class="wp-block-list">
<li>Jefferson (e. S.J.&#8217;s Caviar) – Steen Juul</li>



<li>Just Hans (e. Maharajah) – Bent Svendsen</li>



<li>In My Way Damgård (e. Papagayo E.) – Bo Westergård</li>



<li>Ikon Vang (e. Southwind Frank) – Nicklas Korfitsen (Bo Westergård)</li>



<li>JR (e. Orlando Vici) – Kenneth Andersen (Jeppe Juel)</li>



<li>Icebreaker (e. Chocolatier) – Jeppe Juel</li>



<li>Impressive Hancock (e. Muscle Massive) – Jörgen Sjunnesson (Steen Juul)</li>



<li>Indeed (e. Trixton) – Ken Ecce (Peter Spengler)</li>



<li>Iceman (e. Wishing Stone) – Dennis Kristiansen</li>



<li>Jubii Vang (e. Maharajah) – Flemming Jensen (Bo Westergård)</li>



<li>Joy Me (e. Luckycharm Hanvoer) – Birger Jörgensen (Mariann T.Nielsen)</li>



<li>J J (e. Orlando Vici) – Knud Mönster (Jeppe Juel)</li>
</ol>



<p><a href="https://www.danskhv.dk/media/8400079/Aalborg-070723-tryk.pdf" target="_blank" rel="noreferrer noopener">Här kan du ta del av Ålborgs banprogram till dagens tävlingar.</a></p>



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



<p class="has-drop-cap">5 En kuskmatch mellan franska och svenska amatörer avgörs i Cabourg (första start 18.58) denna fredag.<br>Sune Hansen, Karl Aikio, Alf Nordemo, Jesper von Krusenstierna samt Ann Kristin Rasmusen utgör det svenska laget och den sistnämnda kör svenskfödde <strong>Made of Stars </strong>(e. Super Photo Kosmos) åt sin arbetsgivare Jörgen Westholm.</p>



<p>Prix Unat Rencontre France-Suede (€6.000) är loppet namngivet och körs över 2.725 meter med autostart.</p>



<p>Svenskintresse finns även vid eftermiddagens tävlingar i Feurs (första start 12.55). I Prix Tradibat (€26.000) ska Pierre Vercruysse <strong>Cala Mayor de B.</strong> (e. Muscle Hill) försöka hålla undan 25 meters tillägg för Jean-Michel Bazire-tränade<strong> Hulken Sisu </strong>(e. Readly Express).</p>



<figure class="wp-block-image aligncenter size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/02/hulkensisu1-617x396.jpg" alt="" class="wp-image-406879"/><figcaption class="wp-element-caption">Jean-Michel Bazires Hulken Sisu startar i Feurs. Foto: Gerard Forni.</figcaption></figure>



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



<p class="has-drop-cap">6 Förhandlingarna mellan arbetsgivarorganisationen Almega och fackförbundet Kommunal gällande nytt kollektivavtal för hästskötare hos travtränare är klart.<br>Förvisso en månad efter den ursprungliga tidsplanen, men likväl klart och avtalet är tvåårigt.<br>&#8221;<em>Kollektivavtalet för hästskötare gick ut den 31  maj. Under våren har Almega och Kommunal förhandlat om ett nytt avtal. Det man hade att utgå från var det så kallade ”märket” som sattes av de stora kollektivavtalen för industrianställda under vårvintern. Detta märke innebar att avtalet skulle vara tvåårigt, med 7,4 procents lönehöjning under denna period, varav 4,1 procent av höjningen skulle utgå i år och 3,3 procent nästa år</em>&#8221;, <a rel="noreferrer noopener" href="http://travtranarnasriksforbund.se/arkiv/1904" target="_blank">går att läsa på Travtränarnas Riksförbunds hemsida.</a></p>



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



<p class="has-drop-cap">7 Idag avgörs den norska varianten av Sprintermästaren, nämligen Jarlsberg Grand Prix med försök och final samma kväll och 300.000 kronor till vinnaren i finalen.<br>Tre svensktränade hästar kommer till start i de två försöken varifrån de fem främsta i respektive lopp tar sig vidare till finalen.</p>



<p>Ola Åsebö luftar <strong>Tigermind</strong> (e. Coktail Jet) och Jägersroduon Preben Sövik och Ola Samuelsson bidrar i sin tur med <strong>Just Perfect Sisu</strong> (e. Brillantissime) samt <strong>Roman Tile</strong> (e. Muscle Hill).</p>



<p><strong>Startlista Jarlsberg Grand Prix försök 1</strong><br><em>1.609 meter autostart:</em></p>



<ol class="wp-block-list">
<li>Painted Genius (e. Bar Hopping) – Bo Westergård</li>



<li>Twisted Genius (e. Victor Gio) – Ole Johan Östre</li>



<li>Rockstile R. (e. Maharajah) – Eirik Höitomt (Jan Kristian Waaler)</li>



<li>Born In Bergen (e. Born In The U.S.A.) – Björn Steine (Kim Pedersen)</li>



<li>Petho (e. Propulsion) – Åsbjörn Tengsareid)</li>



<li>Olympic Winner (e. Born In The U.S.A.) – Svein Ove Wassberg (Kim Pedersen)</li>



<li>Just Perfect Sisu (e. Brillantissime) – Preben Sövik</li>



<li>Romas Rile (e. Muscle Hill) – Tom Erik Solberg (Ola Samuelsson)</li>
</ol>



<p><strong>Startlista Jarlsberg Grand Prix försök 2</strong></p>



<p><em>1.609 meter autostart:</em></p>



<ol class="wp-block-list">
<li>Lasse B.R. (e. S.J.’s Caviar) – Per Vetle Kals (Per Otto Aagre)</li>



<li>Tigermind (e. Coktail Jet) – Olav Mikkelborg (Ola Åsebö)</li>



<li>Thai Ohio (e. Brillantissime) – Frode Hamre</li>



<li>Lennon B.R. (e. Muscle Mass) – Magnus Teien Gundersen (Frode Hamre)</li>



<li>I.D.Forecast (e. Village Mystic) – Kristian Malmin</li>



<li>Thai Kansas (e. S.J.’s Caviar) – Bo Westergård</li>



<li>Daddy Pop (e. Papagayo E.) – Vidar Hop (Frode Hamre)</li>



<li>Islandinthesun (e. Executive Caviar) – Anders Lundström Wolden</li>
</ol>



<p>Förstapriset i försöken är 40.000 norska kronor medan finalvinnaren belönas med 300.000 norska kronor.</p>

Fokustema
Morgonsvepet
Läs senare
Auktionstopp gör debut
Om tremiljonersköpet som är redo för tävlingsdebut, storloppskvällen i våra grannländer och en meriterad fransyska som gör sin första start på svensk mark går bland annat att läsa i dagens morgonsvep.
