
<p class="has-drop-cap wp-block-paragraph">Drygt tio miljoner kronor extra ligger i sjurättspotten i lördagens V75-omgång som hämtas från Axevalla.<br>Där avslutar man travåret med att köra Sylvesterloppet (V75-7) för tredje året i följd och får vi rätt så kommer loppet för första gången att vinnas av en häst som inleder på den bakre volten.</p>



<p class="wp-block-paragraph"><strong>Ferrari Sisu </strong>har nämligen återfunnit stilen ordentligt efter en period av blandade resultat. Conrad Lugauers häst övertygade stort vid segern i Hilda Zonetts lopp på Bergsåker i början av månaden och vi tror att han rundar hela fältet ånyo.</p>



<p class="wp-block-paragraph">Omgången känns riktigt svår och vi bedömer det som sannolikt att utdelningen kommer skjuta i höjden.<br>De där spetshästarna som fått hållas i lugnt tempo under vägen och ser ut att vara i mål har en tendens att likväl trilla dit på Axevalla där upploppet&#8230; ja, just det, är långt.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2022/12/31v75.pdf" target="_blank" rel="noreferrer noopener">Här kan du ta del av startlistor till tävlingarna på Axevalla.</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/206687_V75_2022-12-31_8_6" target="_blank">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_2022-12-31_8_6">Sulkysport V75  15 andelar á 150 kr/styck</a></p>



<p class="wp-block-paragraph"><a rel="noreferrer noopener" href="https://www.atg.se/andelskungen/spel/206689_V75_2022-12-31_8_6" target="_blank">Sulkysport Stora V75 – 15 andelar á 250 kr/styck (exklusiv)</a></p>



<h2 class="wp-block-heading">Avd 1 – Diamantstoet, 2.140 meter volstart</h2>



<ul class="wp-block-list">
<li><strong>Kathrine S.H.</strong> vann ett Diamantstoförsök i november via vinnarhålet och här kommer det krävas en annan väg för att det ska gå vägen. Det tror vi dock att hon är förmögen att lösa för insatsen senast på Färjestad som dödenstvåa bakom Babsans Bankir var riktigt strong. Carl Johan Jepson kör Canepa Hanover-dottern för första gången som trampat iväg från snäva startspår tidigare.</li>



<li><strong>Ipanema Beach </strong>får också ny kusk bakom sig då Magnus A Djuse svingar sig upp i vagnen. Hon var mycket tapper senast på Jägersro där hon fick jaga från fjärde utvändigt, men likväl stånkade på hela vägen hem via 1.13,2 sista varvet. Det var en strong insats på skor och tanken av att hon anför det här loppet eller får ett bra lopp längs sargen kittlar.</li>



<li><strong>Loaded Leila</strong> har flyttats fram utvändigt ledaren inför slutrundan i de två senaste starterna och kämpat på starkt även om det inte räckt hela vägen till seger. Hon hanterar tävling med skor på hovarna väl och vann ett Diamantstoförsök på Axevalla i somras.</li>



<li><strong>Queen</strong> höll godkänt från ledningen på en krävande bana senast på Åby. Då var det bara tuffe Crono Delleselve som passerade henne och gången innan höll det hela vägen från samma position. Vi kan se henne hitta ditt på nytt utifrån hur pass bra hon öppnade från spår fem i fjolårets tävlingsdebut.</li>



<li><strong>Make It A Star</strong> såg ut ha mycket sparade krafter då galoppen kom 350 meter före mål senast på Sundbyholm.</li>
</ul>



<p class="wp-block-paragraph"><strong>Rank:</strong></p>



<p class="wp-block-paragraph"><strong>A: </strong>13-1-11 <strong>B:</strong> 5-9-10-12-15-2-14-8 <strong>C: </strong>4-3-7-6</p>



<p class="wp-block-paragraph"><strong>Spetsstriden: Ipanema Beach</strong> öppnade så snabbt ur volten senast att hon ska ha vettig chans att hålla ut <strong>Queen</strong>.</p>



<h2 class="wp-block-heading">Avd 2 – Klass II, 2.140 meter autostart</h2>



<ul class="wp-block-list">
<li><strong>El Vego Khalifa </strong>har segrat i hälften av sina åtta starter såhär långt och övertygat så smått. Näst senast blev loppet rejält överpacat ska sägas, men det var ändå starkt gjort att hinna fram till vinst och det följde han upp med en kontrollerad dödenstriumf på Axevalla med överlägsen marginal. Vi tycker inte att det här Klass II-försöket är &#8221;hur bra som helst&#8221; utan det kan vara så enkelt att han kan forceras fram till tät och bara vinner. Dock vill vi gardera då hästen bara är tre år gammal och ser ut att bli väl stor favorit.</li>



<li><strong>B.B.S.Avicii </strong>avslutade sylvasst bakom Domenik Jet i näst senaste starten och fick därefter chansen på tok för sent för att kunna blanda sig i striden när han testades i ett Klass II-försök på Romme. Hästen har ofta nytta av sin startsnabbhet, men går bra bakifrån. Vi förväntar oss att han rundar många härifrån.</li>



<li><strong>Segway</strong> var en snackhäst i V75 i Halmstad för åtta dagar sedan. Han fick förvisso en småtuff väg fram till ledningen den dagen, men vi tycker ändå inte att han var riktigt lika bra som han varit i starterna dessförinnan. Studsar han tillbaka snabbt är han med och gör upp om segern.</li>



<li><strong>Balzano da Quattro</strong> tycker vi är loppets roliga varning väl medvetna om att han varit struken två gånger efter senaste starten. Hästen var enormt tapper vid dödenskrossen efter tuff inledning näst senast och hängde ett helt varv i tredjespår även i den efterföljande starten innan han nådde dödens. Trots det kämpade han på hela vägen hem som tvåa bakom Hyannis Port och vi tycker det kittlar rejält med Jorma Kontio som kusk bakom den här tuffe Lord Capar-sonen för första gången.</li>



<li><strong>Daniel Frontline </strong>hade vi inte blivit särskilt imponerade av i starterna innan han testades i Klass II på Romme, men då kom han som skjuten ur en kanon över spurtrakan. Var det en tillfällighet eller ett tydligt bevis på att han står sig fint i klassen?</li>
</ul>



<p class="wp-block-paragraph"><strong>Rank:</strong></p>



<p class="wp-block-paragraph"><strong>A: </strong>6-9<strong> B: </strong>4-11-3-10-12-7-5-1 <strong>C: </strong>2-8</p>



<p class="wp-block-paragraph"><strong>Spetsstriden: </strong>Svårbedömt då det inte kryllar av raketer. <strong>Hulk Marke </strong>har öppnat liete mer än medel. Räkna med att Stefan Persson är på noterna och försöker forcera fram och överta med <strong>El Vego Khalifa</strong>.</p>



<h2 class="wp-block-heading">Avd 3 – Flerklasslopp, 2.140 meter voltstart</h2>



<ul class="wp-block-list">
<li><strong>Feline Burgerheide</strong> är en segervan dam med ett brett register. Hon hade ingen lycka när hon testade i Diamantstoet på Jägersro i november, men då fick hon andra utvändigt ledaren. Hon gav aldrig riktigt upp utan höll helt okej som femma och har därefter bärgat två segrar från tät respektive sjätte utvändigt. Öppnar hon någorlunda är chansen god att hon får överta ledningen i tidigt skede och då är hon tveklöst hästen att slå för de övriga.</li>



<li> <strong>Prince Will </strong>höll starkt som dödenstrea bakom bland annat Hilltop Hawk i näst senaste starten och följde upp det med en säker spetsseger på Färjestad. Håkan Petterssons häst vann fyra lopp under den kalla årstiden ifjol och brukar oftast trampa iväg från snäva startspår. Carl Johan Jepsons körstil passar fint ihop med Farifant-sonen som är given i vår A-grupp.</li>



<li><strong>Ready Trophy </strong>brukar lyfta under den årstid då det inte går lika fort i loppen. Senast i Örebro fick han gå utan rygg i tredjespår de sista 900 meterna, men antog den utmaningen och krigade till sig segern via 1.12 sista varvet. Hamnar han inte för mycket på vingel initialt så tror vi att Ready Trophy tar väldigt många under slutvarvet.</li>



<li><strong>Gazza B.R. </strong>är svårbedömd. Han sändes fram till dödens i comebacken och stånkade på helt okej via 1.12 sista 800 meterna utan att det slog gnistor om hästen. Med ett lopp i kroppen är dock sannolikheten stor att han går framåt rätt så rejält.</li>



<li><strong>Jaxon V.S. </strong>blev pressad till galopp i tät senast och fick därefter vandra i dödens. Han gick inte alls att känna igen den dagen och behöver prestera som vid dödensvinsten gången innan om han ska vara en faktor i det här loppet.</li>
</ul>



<p class="wp-block-paragraph"><strong>Rank:</strong></p>



<p class="wp-block-paragraph"><strong>A: </strong>3-9-12 <strong>B: </strong>7-10-13-6-1-11 <strong>C: </strong>8-11-2-14-5-15-4</p>



<p class="wp-block-paragraph"><strong>Spetsstriden: </strong>Den av<strong> Donatello Wibb </strong>och <strong>Vikens Ale </strong>som frontar lär överlåta taktpinnen till <strong>Feline Burgerheide</strong> per omgående. Är hon inte riktigt med på noterna initialt finns dock en risk att <strong>Prince Will </strong>snabbt är framme och utmanar om att få vara anförare&#8230;</p>



<h2 class="wp-block-heading">Avd 4 – Fyraåringslopp, 2.140 meter voltstart</h2>



<ul class="wp-block-list">
<li><strong>Breidabliks Bombay</strong> blir vårt tipsval i ett av de mer öppna V75-lopp som vi har tippat. Han har gjort tre starter efter 14 månaders tävlingsuppehåll och lyft undan för undan. I de två första starterna blev det andraplatser från vinnarhålet och senast kom han aldrig till i ett Klass II-försök hemma på Jägersro efter att fått backas ner i sjätte utvändigt. Från springspår finns det viss chans att det bär av till ledningen och då tror vi att Conrad Lugauer vill testa och köra i den positionen.</li>



<li><strong>Crono Delleselve</strong> har visat hög högstanivå och var åter sig lik i senaste starten på Åby. Han hamnade oväntat bra till från tredje ledet i en spårtrappa och när Carl Johan Jepson tryckte på gaspedalen i slutkurvan så avgjorde Mondiale O.K.-sonen lekande lätt. En likvärdig prestation här räcker mycket långt.</li>



<li><strong>Rendez Vous</strong> vann från dödens i comebacken efter tio månaders frånvaro på Jägersro, men har därefter galopperat efter 150 meter två starter i följd. Lyckas Åke Svanstedt få hästen på bättre tankar och rentav hålla ut vår tipsetta är Rendez Vous en het kandidat.</li>



<li><strong>Vivacious</strong> kom inte förbi What A Winner i Mantorp, men fick revansch i efterföljande start på Sundbyholm under julafton då han var överlägsen efter forcering till tät. Fyraåringen är i toppslag just nu och kan komma fram fint längs sargen om det vill säg väl då det är få hästar på startvolten.</li>



<li><strong>Ontario Bro </strong>spurtade strålande bakom V75-bekante Timo Jutila i Bollnäs och höll helt okej senast på Sundbyholm efter en tuff öppning. I lag med Ulf Ohlsson är hästen värd en varning.</li>
</ul>



<p class="wp-block-paragraph"><strong>Rank:</strong></p>



<p class="wp-block-paragraph"><strong>A:</strong> 6-11 <strong>B: </strong>4-14-13-9-7-3-1-8-15-12 <strong>C: </strong>10-5&#8211;2</p>



<p class="wp-block-paragraph"><strong>Spetsstriden: Ding Dong </strong>kan få svårt tt hålla ut <strong>Breidabliks Bombay</strong>. <strong>Rendez Vous </strong>var med ganska bra från snävt spår i senaste starten, men galopperade efter 150 meter. Lyckas Åke Svanstedt hålla honom i rätt gångart och samtidigt öppna raskt?</p>



<h2 class="wp-block-heading">Avd 5 – Bronsdivisionen, 2.140 meter autostart</h2>



<ul class="wp-block-list">
<li><strong>Without A Doubt</strong> har inte riktigt haft rätt studs i de mer penningstinna loppen under året även om han vann ett Klass I-försök på Jägersro i september. I genrepet visade han återigen att han fungerar fint på skor då han bombade hem det loppet från tät och det är sannerligen inte enkelt att ta emot Hard Livin-sonen i spetsjakten. De innersta spåren är gynnsamma på Axevalla ska dock sägas och vi vågar inte lägga alla ägg i samma korg och spika Patricia van der Meers fyraåring.</li>



<li><strong>Elephant</strong> fick tuff press i ledningen näst senast och höll med tanke på det starkt som tvåa. Han revanscherade sig med enkel spetsseger gången efter och är i så pass bra slag just nu att han måste räknas tidigt.</li>



<li><strong>Conch On Inn </strong>har studsat tillbak aunder årets andra halva efter en inledning med blandade resultat. Han var riktigt fin vid spetssegern näst senast och höll bra som dödenstvåa på Carl Halbak senast via 1.11,7 sista 800 meterna. Oavsett om han frontar eller får ett gynnsamt lopp där bakom i draget så är han med och gör upp om segern.</li>



<li><strong>Vinci Nice</strong> har suttit fast två starter i följd och sett fin ut. Det är inge barnlek att komma till från det här utgångsläget, men fyraåringen är en mycket stark spurtare om det stämmer någorlunda på vägen.</li>



<li><strong>Gaylord Am </strong>var femma i Sylvesterloppet motsvarande tävlingsdag ifjol trots galopp. Hästen har fyra lopp i kroppen efter uppehåll och var positiv vid spetssegrn senast där han höll stången mot Powerbank i slutskedet.</li>
</ul>



<p class="wp-block-paragraph"><strong>Rank:</strong></p>



<p class="wp-block-paragraph"><strong>A: </strong>3-2-1 <strong>B: </strong>7-12-4 <strong>C: </strong>11-9-10-5-6-8</p>



<p class="wp-block-paragraph"><strong>Spetsstriden: </strong>Snabba hästar på de tre innersta spåren. <strong>Without A Doubt </strong>brukar vara raskast, men innerspår är riktigt bra på Axevalla med den långa accelerationssträcka man får innan bilen släpper fältet och ska de kunna hålla ut honom någonstans när de står sida vid sida så är det just här.</p>



<h2 class="wp-block-heading">Avd 6 – Klass I, 1.640 meter autostart</h2>



<ul class="wp-block-list">
<li><strong>Babsans Bankir </strong>är en tuff herre som vi verkligen gillar. Han kom inte alls till i Klass I-försöket på Solvalla näst senast, em gick i mål med en hel del sparade krafter i skymundan. Gången efter kunde han forceras till tät halvvägs in i loppet och var aldrig nära att släppa tag om det loppet. Mycket talar för att det blir krävande förusättningar efter nederbörd på Axevalla vilket den här hästen hanterar fint och då går det hämta längder från de bakre regionerna. Spelprocenten är kittlande låg och utifrån det väljer vi att chansspika.</li>



<li><strong>Kövras Joker</strong> har tagit två raka spetssegrar efter att forcerats dit efter första kurvan. Han har svarat ärligt och säkert i slutskedet och varit bra. Hästen har hävdat sig väl även i STL-sammanhang tidigare och skulle det bli så att han avgör spetsstriden &#8221;på två steg&#8221; och inte öppningen blir så krävande är det givetvis fördel för Pojke Kronos-sonen.</li>



<li><strong>Theycallmesixten</strong> är stallkamrat med Kövras Joker och en bra sådan. Han var tapper från tät på en topptid i ett Klass II-försök på Färjestad i september och vann väldigt enkelt från ledningen i genrepet. Den här gången ska hästen tävla med jänkarvagn för första gången vilket kittlar.</li>



<li><strong>Andover Heaven </strong>avslutade jättebra från femte utvändigt näst senast, men borde hakat på lite bättre bakom <strong>Global Believer </strong>gången efter då han fick vinnarhålet. På utgångsläge och det han visat dessförinnan får dock hästen vår outsiderröst.</li>



<li><strong>What A Winner </strong>har varit riktigt rejäl i vardagssammanhang på sistone och det ska bli spännande att se vad Åke Svanstedt kan få ut ur den här hästen.</li>
</ul>



<p class="wp-block-paragraph"><strong>Rank:</strong></p>



<p class="wp-block-paragraph"><strong>A:</strong> 9-3-7 <strong>B: </strong>1-5-6-4-2-11 <strong>C: </strong>10-12-8</p>



<p class="wp-block-paragraph"><strong>Spetsstriden: </strong>Ovanligt tunt med startblixtar sett till klassen samt att det är sprinterdistans. Allt tyder på att <strong>Kövras Joker </strong>frontar och håller ut stallkamraten <strong>Theycallmesixten</strong> som är det tydligaste hotet.</p>



<h2 class="wp-block-heading">Avd 7 – Sylvesterloppet, 2.640 meter voltstart</h2>



<ul class="wp-block-list">
<li><strong>Ferrari Sisu</strong> har haft en stark höst och vinter. Sjuåringen fick långt fram till Staro Leonardo i näst senaste starten i Halmstad, men jagade ifatt stegen före mål. Senast i Hilda Zonetts lopp på Bergsåker backades han ner som sistahäst och hade långt fram då han fick slå följe i tredjespår 400 meter, men via en virvlande avslutning i vida spår hann han fram till vinst i sista steget. Klockan visade 1.10,3 för hans avslutande kilometer och det var verkligen en rejäl insats. Hästen har varit struken på grund av opassande banförhållande efter det, men det fäster vi inte så stor vikt vid. I ett jämnt, bra lopp är Ferrari Sisu ändå den häst som sticker ut en aning och vi tror han rundar hela gänget.</li>



<li><strong>Hooper des Chasses </strong>vann klassiska Graf Kalman i Wien i oktober mot elithästar. I senaste starten på Åby galopperade han från start, men gick en svettig upphämtning i skymundan via 1.10,8 sista 2.100 meterna. Det var faktiskt full fart på hästen hela vägen in till linjen och den här femåringen är mycket bättre än vad gemene spelare tycks tro. Även Hooper des Chasses har varit struken efter senaste starten och då på grund av sårskada, men det tar vi lätt vid. Klarar han av det snäva startspåret är han med i striden.</li>



<li><strong>Certainly</strong> vann ett penningstint stayerlopp hemma på Sundbyholm i somras. I genrepet inför detta lopp blev han fint framdragen och avslutade starkt som tvåa. Den insatsen på skor var så pass duglig att han tar plats i vår A-grupp.</li>



<li><strong>Vice Versa Diamant </strong>är årets mest segerrika häst på svensk mark med tio segrar. Blott en av dem är tagen i lopp med sexsiffrigt förstapris vilket var Salatrofén i november där han hittade till tät i tidigt skede från tillägg. Totalt har hästen gjort åtta starter i lopp med sexsiffrigt förstapris på svensk mark och det är bara i Salatrofén som hästen har placerat sig bland de tre främsta. Vi har en tro på att han blir överspelad i detta lopp kontra faktisk vinstchans, väl medvetna om att han har en påtaglig styrka.</li>



<li><strong>Gasolin</strong> vann Jydsk Grand Prix i somras och slutade trea i finalen av Danskt Travderby. Steen Juuls häst var urtapper i senaste starten i Nyköping Falster där han stod pall för en 1.10,8-öppning på mycket krävande bana. Gasolin är absolut värd att spela outsiderrollen.</li>
</ul>



<p class="wp-block-paragraph"><strong>Rank:</strong></p>



<p class="wp-block-paragraph"><strong>A: </strong>14-9-11 <strong>B: </strong>7-8-4-15-3-5-6-12 <strong>C: </strong>2-1-10-13</p>



<p class="wp-block-paragraph"><strong>Spetsstriden: Bottnas Idol</strong> är knapp spetsfavorit gentemot <strong>Calamari</strong>. Han har öppnat bra ur volten tidigare, men inte haft framspår i voltstart på över ett och halvt år så det föreligger lite frågetecken kring hur han hanterar det.</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">
									V75-FÖRSLAGET 31 DECEMBER								</h3>
<div class="content">
<p class="wp-block-paragraph"><strong>Avd 1: </strong>1,5,9,10,11,12,13,15 (2,14)<br /><strong>Avd 2: </strong>4,6,9,11 (3,10)<br /><strong>Avd 3: </strong>3,9,12 (7,10)<br /><strong>Avd 4: </strong>1,3,4,6,7,9,11,13,14 (10,5)<br /><strong>Avd 5: </strong>1,2,3,7,12 (4,11)<br /><strong>Avd 6: </strong>9 Babsans Bankir (3,7)<br /><strong>Avd 7: </strong>14 Ferrari Sisu (9,11)</p>
<p class="wp-block-paragraph"><em>4.320 rader / 2.160 kronor</em></p>
</p></div>
</p></div>
</p></div>
</p></div>
</p></div>
</p></div>
