
<p class="has-drop-cap wp-block-paragraph">1Den 30 oktober 1993 kördes den allra första V75-omgången på Jägersro och en blivande dubbel Elitloppsvinnare vann det första loppet. <strong>Copiad</strong> (e. Texas) och Erik Berglöf inledde från bakspår i V75-premiären för fyraåringar med en kvarts miljon kronor till vinnaren, men gjorde slag i saken och tog över ledningen mitt i loppet. Sedan blev segern knapp men säker före Bolets Igor.<br>En succéartad spelform var född och ett nytt storlopp hade gjort sitt intåg. Under 20 år firades spelformen med jubileumsloppet som efterhand blev ett fyra- och femåringslopp. Internationella stjärnor som <strong>Giesolo de Lou, Atom Tess, Dream of Gold, Oscar Schindler S.L. </strong>och <strong>Atom Tess</strong> har sällskap av svensktränade vinnare som <strong>Super Photo Kosmos, Opal Viking, Colombian Necktie, Yield Boko</strong> och <strong>Sanity</strong>.</p>



<p class="wp-block-paragraph">20-årsjubiléet firades 2013 med Jörgen Westholm-tränade <strong>Rocky Winner</strong> (e. Credit Winner) och Peter Ingves. Hela 500.000 kronor var förstapriset – precis som åren 2008-2012 – men vilka har vunnit efteråt? Svaret är – inga! V75:s jubileumslopp gick i graven efter 20 år och när spelet ska firas idag är det som ett vanligt bronsdivisionsförsök med 110.000 kronor till vinnaren…</p>



<p class="wp-block-paragraph">Godbiten är istället Jägersros klassiker C.L. Müllers Memorial med ett möte mellan Daniel Redéns Åby Stora Pris-vinnare <strong>Admiral As </strong>(e. Ready Cash) och Robert Berghs svenske mästare <strong>Power</strong> (e. Googoo Gaagaa) i kamp om 400.000 kronor i förstapris. <br><a rel="noreferrer noopener" href="https://sulkysport.se/v75-riktigt-fin-att-skada/" target="_blank">Så här säger Robert Bergh om sina V75-chanser.</a></p>



<p class="wp-block-paragraph">En annan anrik löpning är Johan Jacobssons Minne för tre- och fyraåringar med en magnifik silverpokal värd 200.000 kronor som vandringspokal. Här kan det bli mer Redén vs Bergh – Redén mönstrar Derbyfinalistern <strong>Jikken</strong> (e. Propulsion) från tillägg medan Berghs långa E3-finalist <strong>Capricon Trot</strong> (e. International Moni) finns på startfållan i kamp om förstapriset på 150.000 kronor.</p>



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



<p class="has-drop-cap wp-block-paragraph">2Så här säger Sulkysports tipsexpert om sitt roligaste spikförslag i V75:s jubileumsomgång på Jägersro.<br><em>”Roligaste spiken är istället <strong>Ninja Zon</strong> (V75-5) som såg helt ljuvlig ut i debuten för André Eklundh. Stoet har tre V75-segrar på sitt cv sedan tidigare och känns superspännande från ett perfekt utgångsläge i en spårtrappa där vi inte tycker att de mer rutinerade hästarna nödvändigtvis ska vara bättre än henne.”</em></p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/10/ninjazon1-617x333.jpg" alt="" class="wp-image-515550"/><figcaption class="wp-element-caption">Ninja Zon, här med Markus Niklasson, tränas numera av André Eklundh och spikas inom lördagens V75-omgång. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="wp-block-paragraph">André Eklundh själv var överraskad, på ett positivt sätt, efter segern i första starten i hans regi på Färjestad för knappt två veckor sedan.<br>– Hon var svårbedömd innan, jag hade varit nöjd med henne i träning men inte kört något banjobb utan bara intervaller. Vi fick .loppet lite kört i halsen och hon trivs med sådana löpningar, men hon gick med full fart över mål och både norsken och tussarna var oryckta. Historiskt sett har hon varit bäst i ryggar, men om jag tar mig förbi ”Bergharn” (Robert Bergh med innerspårets Carroty) från början är jag inte främmande för att prova i ledningen. Hon startar med vinstchans, sade Eklundh till V65 Direkt.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/spelstugan/v75-tips-28-oktober/" target="_blank" rel="noreferrer noopener">––> Här är stora tipsgenomgången med analyser, spetsstrider, systemförslag och ranking av alla hästar på V75.</a></p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2023/10/28v75.pdf">Här kan du ta del av startlistor till tävlingarna på Jägersro.</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 href="https://www.atg.se/andelskungen/spel/206687_V75_2023-10-28_7_5">Sulkysport Lilla V75 – 15 andelar á 75 kr/styck</a></p>



<p class="wp-block-paragraph"><a href="https://www.atg.se/andelskungen/spel/206688_V75_2023-10-28_7_5">Sulkysport V75 – 15 andelar á 150 kr/styck</a></p>



<p class="wp-block-paragraph"><a href="https://www.atg.se/andelskungen/spel/206689_V75_2023-10-28_7_5">Sulkysport Stora V75 – 15 andelar á 250 kr/styck</a></p>



<p class="wp-block-paragraph">Före och efter Jägersros tävlingar väntar breddlopp. Hagmyren (start 11.10) sätter punkt för säsongen med start på förmiddagen och Färjestad (start 18.30) avslutar till kvällen.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2023/10/231028.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till lördagens tävlingar.</a></p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2022/10/specialway2-617x363.jpg" alt="" class="wp-image-374298"/><figcaption class="wp-element-caption">Special Way går undan till seger i BC-finalen för tvååriga ston för Åke Svanstedt 2022. Foto: Gerard Forni</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">3Förra året vann han tre av sex Breeders Crown-finaler. I natt på Hoosier Park kan Åke Svanstedt fylla på med fler tunga triumfer. Åke finns med i alla och har totalt sju hästar till start i finalerna för treåringar och äldre hästar.</p>



<p class="wp-block-paragraph">Två av finalisterna vann Breeders Crown-final redan förra året, nämligen svenskfödda <strong>Jiggy Jog</strong> (e. Walner) och <strong>Special Way</strong> (e. Walner). Åkes tredje vinnare ifjol var danskfödde <strong>Ecurie D. </strong>(e. Infinitif), som även vann för äldre hästar 2021. Åkes femte BC-vinnare är en annan svenskfödd travare, <strong>Felicity Shagwell</strong> (e. Maharajah) som slog till 2021 för äldre ston och den sjätte kom i natt bakom<strong> Warrawee Michelle</strong> (e. Walner) för tvååriga ston.</p>



<p class="wp-block-paragraph"><strong>Svenska tränarnas hästar i BC-finalerna:</strong></p>



<ul class="wp-block-list">
<li><strong>Treåriga h/v ($672.000): </strong>Up Your Deo (Åke Svanstedt), Kilmister (Marcus Melander), Air Power (Melander), Dire Straits (Melander), Tactical Approach (Nancy Takter)</li>



<li><strong>Treåriga ston ($600.000): </strong>Special Way (Svanstedt), Bond (Svanstedt), Bravo Angel (Jonas Czernyson), Heaven Hanover (Melander), Quick Stop (Anette Lorentzon)</li>



<li><strong>Äldre hästar ($600.000): </strong>Southwind Tyrion (Svanstedt), Pretender (Takter), Alrajah One (Svanstedt), Rattle My Cage (Svanstedt)</li>



<li><strong>Äldre ston ($400.000): </strong>Jiggy Jog (Svanstedt)</li>
</ul>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/svanstedt-laddar-med-tolv/" target="_blank" rel="noreferrer noopener">Här är alla startlistor till Breeders Crown-finalerna.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">4Vincennes (första start kl. 12.05) arrangerar dubbla semi classique-lopp för treåringar under eftermiddagen. I hingstklassen Prix Victor Regis (€120.000) går Tomas Malmqvists <strong>Kapitano de Source</strong> (e. Ready Cash) upp i ringen mot Sébastien Guaratos Criterium des 3 ans-vinnare <strong>Krack Time Atout</strong> (e. Face Time Bourbon) och i stoklassen Prix Uranie (€120.000) tävlar Stall Courant-ägda <strong>Kalmia Perrine</strong> (e. Django Riff) i lag med Théo Duvaldestin.</p>



<p class="wp-block-paragraph">Evakueringsloppet Prix de Nancy (€53.000) är lördagens svensktätaste lopp då fyra av de 18 deltagarna är svenskfödda. Markus B Svedberg bidrar med såväl <strong>Certainly</strong> (e. Readly Express) som <strong>Kimi di Quattro</strong> (e. Maharajah), Eskilstunakollegan Jörgen S Eriksson med <strong>Dollar Doc</strong> (e. Ready Cash) och så gör Mattias Djuses <strong>Global Bookmaker</strong> (e. Broadway Hall) sin andra start på fransk mark efter att inlett med en femteplats i Le Mont-Saint-Michel-Pontorson i slutet av september.</p>



<p class="wp-block-paragraph">Sadelloppet Prix de Berck-sur-Mer (€46.000) innehåller likaså två blågula inslag. <strong>Django Silver</strong> (e. Django Riff) gör debut på fransk mark och därtill sin första start i Christoffer Erikssons regi. Femåringsloppet innehåller även <strong>Invader Am</strong> (e. Muscle Hill) tränad av Laurent Claude Abrivard.</p>



<p class="wp-block-paragraph">Tävlingsdagen inleds med två tvååringslopp och i inledande Prix de Milly La Foret (€43.000) finns Tomas Malmqvist representerad genom Love You-dottern <strong>Lizy Josselyn</strong> som inlett karriären med en seger och en diskvalifikation.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/trav-och-galopp/paris-vincennes-2023-10-28/" target="_blank" rel="noreferrer noopener">Här kan du ta del av dagens startlistor till tävlingarna på Vincennes.</a></p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2022/12/jorgenwestholm1-617x333.jpg" alt="" class="wp-image-392828"/><figcaption class="wp-element-caption">Jörgen Westholm. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="wp-block-paragraph">Det finns ett travliv även utanför den franska nationalarenan Vincennes som är värt att belysa. Till gräsbanan i Moulins (första start kl. 13.00) sänder Ron Kuiper och Jörgen Westholm två hästar vardera.<br>I försäljningsloppet Prix du Credit Agricole Centre France (€10.000) startar duon varsin häst till start då Kuipers <strong>Heros</strong> (e. The Best Madrik) har ett grundpris på 6.000 euro för den intresserade och Westholms <strong>Horizon du Gers</strong> (e. Bold Eagle) är prissatt till 10.000 euro.<br>Kuiper och Westholm möts även i tävlingsdagens huvudlopp Grand Prix Jean Tortel (€20.000) där de tävlar med <strong>Fun de la Loge</strong> (e. Rolling d’Heripre) respektive <strong>Made of Stars</strong> (e. Super Photo Kosmos) och loppet innehåller även svenskfödde <strong>Rapide Yoda</strong> (e. Up And Quick).</p>



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



<p class="has-drop-cap wp-block-paragraph">5Ett av Finlands största treåringslopp är Kymenlaakso-Ajo (€90.000), där vinnaren plockar hem 36.000 euro. Det som skiljer många andra större lopp är att loppet både avgörs i voltstart med två volter och att hästarna på startfållan fått tjäna max 7.000 euro inför försöken.<br>Dessa var fyra till antalet och avgjordes förra torsdagen med idel vinnare från startfållan. <strong>Viens Ici, Club Nord Aurora, Insorto</strong> och <strong>Fly By Me</strong> segrade. Markus Dahlgrens Club Nord Aurora är fortsatt obesegrad efter tre starter, medan Viens Ici vunnit fyra av fem – enda förlusten kom som 16-för-tio-favorit i finska Kriteriekvalet.<br>Att plocka in 20 meter på dessa blir en tuff uppgift för de tre tilläggshästarna, där <strong>Sahara Commander</strong> har de främsta meriterna och rutinen. Tommi Kylliänens travare vann Breeders Crown-final som tvååring.</p>



<h2 class="wp-block-heading">Startlista Kymenlaakso-Ajo (€91.000)</h2>



<p class="wp-block-paragraph">2.100 meter voltstart, förstapris 36.000 euro<br><em>Häst (far) – Kusk (tränare)</em></p>



<ol class="wp-block-list">
<li>Viens Ici (e. Quite Easy) – Santtu Raitala (Tero Pohjolainen)</li>



<li>Club Nord Aurora (e. Andover Hall) – Markus Dahlgren</li>



<li>Insorto (e. Jontte Boy) – Esa Holopainen (Anton Punkka)</li>



<li>Quiddish Wurst (e. Spider Blessed) – Ilkka Korpi (Taisto Bordi)</li>



<li>No Limit Giant (e. Conway Hall) – Pekka Korpi</li>



<li>Fly By Me (e. Muscle Mass) – Harri Koivunen</li>



<li>Art Flower (e. Enjoy Lavec) – Hannu Torvinen (Joni-Petteri Irri)</li>



<li>Fortnite (e. Le Monteil) – Olli Koivunen (Harri Koivunen)</li>



<li>Cool Flame (e. Flocki d’Aurcy) – Antti Teivainen (Joni-Petteri Irri)<br><em>2.120 meter:</em></li>



<li>An-Lisa (e. Lexus Font) – Robert Lindgren (Reino Palamäki)</li>



<li>Sahara Commander (e. R.C.Royalty) – Tommi Kylliänen</li>



<li>Karelin Avenger (e. Le Monteil) – Jani Routsalainen (Pasi Pörsti)</li>
</ol>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/05/hohneck8-617x333.jpg" alt="" class="wp-image-450034"/><figcaption class="wp-element-caption">Philippe Allaire. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">6En resa utvändigt ledaren var inget hinder för Philippe Allaire-ägda <strong>Filadonna</strong> (e. Muscle Hill) i fredagens uttagningslopp till Gran Premio Anact (€20.900) i italienska Treviso.<br>Med tre längder som segermarginal höll hon ifrån sig stallkamraten <strong>Fantaghiro’ Grif</strong> (e. Nad Al Sheba) och kom i mål på 1.15,0a/1.609 meter.<br>Det andra uttagningsloppet i stoklassen gick till Fausto Barelli-tränade <strong>Francy Caf</strong> (e. Nad Al Sheba) i lag med Pietro Gubellini på 1.16,8a/1.609 meter och hon fick även med sig Flores de Campo (e. Ringostarr Treb) till finalen.</p>



<p class="wp-block-paragraph"> I hingstklassen vann Gennaro Casillo-tränade <strong>Frankie LJ</strong> (e. Readly Express) på 1.15,0a/1.609 meter i lag med Antonio di Nardo följd av Expo Wise As-brodern <strong>Fellow Wise As</strong> (e. Maharajah) samt Fausto Barellis <strong>Fil Ek</strong> (e. Ringostarr Treb) på 1.15,0a/1.609 meter före Flamino (e. Ready Cash).</p>



<p class="wp-block-paragraph">Finalerna avgörs i Turin den 18 november och då står 200.200 euro på spel i respektive klass.</p>



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



<p class="has-drop-cap wp-block-paragraph">7Igår var det internetauktion i ASVT:s regi med 38 hästar utbjudna till försäljning. Ikväll är det dags för auktionsaktören Travera, där 46 hästar och en hingstandel i <strong>Trixton</strong> är till salu.</p>



<p class="wp-block-paragraph">Merparten av de fyrbenta är starthästar, 23 till antalet. Bland dessa finns halvmiljonärskan <strong>Sweet And Wild</strong> (e. The Bank), sexfaldige miljonären Policy Of Truths lillebror <strong>Hickoexplosive</strong> (e. Explosive Matter) och <strong>Luca di Quattro</strong> (e. Ready Cash) för att nämna några.<br>15 fölston bjuds ut och ett av dessa är sexåriga <strong>Cash And Carry</strong> (e. From Above), 1.11,3ak*/698.750 kr. En tvååring efter Muscle Hill och ettåringar med fäderna Beer Summit, Eridan, From Above, Nuncio, Raja Mirchi, Varenne och Winner’s Wine finns bland de yngsta.</p>



<p class="wp-block-paragraph"><a href="https://www.travera.nu/kopa-hast/" target="_blank" rel="noreferrer noopener">Här går det att se hästarna som bjuds ut och följa budgivningen under kvällen.</a></p>

Fokustema
Morgonsvepet
Läs senare
Från Copiad till – ingenting
V75 firar 30 år med bronsdivisionsförsök. Tussar och norskt oryckt vid seger i V75-genrep. Svanstedt fyller på prisskåpet i Breeders Crown? Treåringsklassiker på Vincennes. Storpott för orutinerade treåringar.
Detta och mer i lördagens ”Sju nyheter vid sju”.
Detta och mer i lördagens ”Sju nyheter vid sju”.
